Question

我有一个（大约100个）值的列表，如此列表：

list = ['40201020', '45102020', '25203020', '20106020', '25301020', '40402030', '20202010']

我需要一本字典

a）列出每个值的所有父母。父母的数字少了一位（从右边开始）：

child = '40201020'
parent = '4020102'

这种格式是理想的：

dict['4020102parent'] = '40201020'

b）我需要父母的所有父母，最多剩下一位数。所以父母'4020102'得到这个父母：

dict['4020102parent"] = '402010'

和

dict['402010parent"] = '40201'

等

然后，我需要为每个父母的所有最后的后代作为列表。最后一个后代，我的意思是原始列表的8位数代码。因此数字'4'将具有以下代码：

dict['4children'] = ['40201020', '45102020', '40402030']

或：

dict['40children'] = ['40201020', '40402030']

Answer 1

您的列表是否始终包含字符串并且是字典的要求？如果你总是使用字符串而你只是想找到父母和孩子的方法，我会建议使用python的字符串处理功能。您可以像这样定义函数parent和children：

def parent(list_item):
    return list_item[:-1]

def children(my_list, parent_str):
    children_found = []
    for item in my_list:
        if item.startswith(parent_str)
            children_found.append(item)
    return children_found

然后调用parent('40201020')会产生'4020102'，调用children(my_list, '40')会产生['40201020', '40402030']。您可以递归地调用父级来获取每次少一个项目的字符串。

Answer 2

我仍然感到困惑，为什么你需要父dict时你可以将递归结果存储在列表中并且可以使用str.startswith（）方法：

我仍然在dict_data中存储了parentdict你可以使用它：

{SourceContext}

输出：

list1 = ['40201020', '45102020', '25203020', '20106020', '25301020', '40402030', '20202010']

dict_data=[]
track=[]
list_2={}

def main_function(lst_1):
    for i in lst_1:
        def recursive(lst):
            parent = {}
            if not lst:
                return 0
            else:
                parent[lst[:-1] + 'parent'] = lst
                track.append(lst)
                dict_data.append(parent)


            return recursive(lst[:-1])

        recursive(i)
main_function(list1)

for recursive_unit in set(track):
    for items in list1:
        if items.startswith(recursive_unit):
            if recursive_unit not in list_2:
                list_2[recursive_unit]=[items]
            else:
                list_2[recursive_unit].append(items)

print(list_2)

Answer 3

正如我的评论中所述，每个键包含孩子的字典似乎是一个更合理的想法。

为了实现这一点，我们可以遍历列表中的每个元素（我将其重命名为l，以便不覆盖内置的list()函数），并将此值附加到列表中所有父母都在字典中，d。

上述方法的代码看起来像是：

d = {}
for i in l:
    for e in range(1, len(l)-1):
        d.setdefault(i[:e], []).append(i)

然后允许您执行以下操作：

>>> d['4']
['40201020', '45102020', '40402030']
>>> d['40']
['40201020', '40402030']
>>> d['25']
['25203020', '25301020']

Answer 4

# do not use "list" as variable name (it's a python builtin)
mylist = ['2', '20', '201', '2010', '20106', '201060', '2010602']
mylist_sorted = mylist.clone()
mylist_sorted.sort()
parents = {}
children = {}
for element in mylist_sorted:
    parents[e] = []
    children[e] = []
    for subelement in [element[0:x] for x in range(1,len(element))]:
        if subelement in parents:
            parents[element].append(subelement)
            children[subelement].append(element)
print(parents)
print(children)

输出：

{'201060': ['2', '20', '201', '2010', '20106'],
 '20106': ['2', '20', '201', '2010'],
 '2010': ['2', '20', '201'],
 '201': ['2', '20'],
 '2': [],
 '2010602': ['2', '20', '201', '2010', '20106', '201060'],
 '20': ['2']}

{'201060': ['2010602'],
 '20106': ['201060', '2010602'],
 '2010': ['20106', '201060', '2010602'],
 '201': ['2010', '20106', '201060', '2010602'],
 '2': ['20', '201', '2010', '20106', '201060', '2010602'],
 '2010602': [],
 '20': ['201', '2010', '20106', '201060', '2010602']}

来自分层代码列表的递归字典

4 个答案: