如何在多个字典中创建字典，而不覆盖旧数据

Question

我有一个在字典中创建字典的数据列表，它的结构如预期的那样出现，但在某个地方被覆盖了，我不知道在哪里

a=['t1_h1','t2_h2']
b=['h1_d1','h1_d2','h2_d3']
c=['d1_dom1','d2_dom2','d3_dom3']
d=['dom1_a','dom1_b','dom2_a','dom2_b','dom3_a','dom3_b']

我试着使用下面的代码

for item in a:
f[item.split('_')[0]]={}
for hypercube in b:
    if item.split('_')[1] in hypercube:#h1 in b

        f[item.split('_')[0]][item.split('_')[1]]={}

        for dimension in c:
            if hypercube.split('_')[1] in dimension:#d1 in c 
                f[item.split('_')[0]][item.split('_')[1]][hypercube.split('_')[1]]={}
                for domain in d:
                    if dimension.split('_')[1] in domain:#dom1 in d
                        if f[item.split('_')[0]][item.split('_')[1]][hypercube.split('_')[1]].has_key(dimension.split('_')[1]):
                            f[item.split('_')[0]][item.split('_')[1]][hypercube.split('_')[1]][dimension.split('_')[1]].append(domain.split('_')[1])
                        else:
                            f[item.split('_')[0]][item.split('_')[1]][hypercube.split('_')[1]][dimension.split('_')[1]]=[domain.split('_')[1]]

实际上，我正在尝试以这种格式打印：

{'t1': {'h1': {'d1': {'dom1': ['a', 'b']}, 'd2': {'dom2': ['a', 'b']}}},
     't2': {'h2': {'d3': {'dom3': ['a', 'b']}}}}

但我得到的输出是：

{'t2': {'h2': {'d3': {'dom3': ['a','b']}}}, 't1': {'h1': {'d2': {'dom2': ['a','b']}}}}

但在更改't1‘中的最后一项内容后，缺少'd1’值

Answer 1

你不想嵌套你的for循环，你想在处理每个列表a，b，c和d时嵌套for搜索，向f添加越来越深的层次。这给出了你想要的输出：

f = {}
for item in a:
    ak1,ak2 = item.split('_')
    f[ak1] = {ak2:{}}
for item in b:
    bk1,bk2 = item.split('_')
    next(f[akey][bk1] 
            for akey in f 
                if bk1 in f[akey])[bk2] = {}
for item in c:
    ck1,ck2 = item.split('_')
    next(f[akey][bkey][ck1] 
            for akey in f 
                for bkey in f[akey] 
                    if ck1 in f[akey][bkey])[ck2] = []
for item in d:
    dk1,dk2 = item.split('_')
    next(f[akey][bkey][ckey][dk1] 
            for akey in f 
                for bkey in f[akey]
                    for ckey in f[akey][bkey]
                        if dk1 in f[akey][bkey][ckey]).append(dk2)

import pprint
pprint.pprint(f)

打印：

{'t1': {'h1': {'d1': {'dom1': ['a', 'b']}, 'd2': {'dom2': ['a', 'b']}}},
 't2': {'h2': {'d3': {'dom3': ['a', 'b']}}}}

Answer 2

我认为这是使用defaultdict的一个很好的例子

from collections import defaultdict

def new_dict(items):
    items = [i.split('_') for i in items]
    d = defaultdict(list)
    for k, v in items:
        d[k].append(v)
    return dict(d)

def combine(x,y):
    for i in x:
        x[i] = dict((j,y[j]) for j in x[i])
    return x

a, b, c, d = [new_dict(i) for i in [a, b, c, d]]

c=combine(c,d)
b=combine(b,c)
a=combine(a,b)
print a
#Output:
{'t2': {'h2': {'d3': {'dom3': ['a', 'b']}}},
't1': {'h1': {'d2': {'dom2': ['a', 'b']}, 'd1': {'dom1': ['a', 'b']}}}}

new_dict通过将输入字符串拆分成键和值来返回dict。最酷的一点是，通过使用defaultdict，我们可以轻松地将额外的键值附加到键上，而无需进行任何检查，例如：

['h1_d1','h1_d2','h2_d3']变成：{'h2': ['d3'], 'h1': ['d1', 'd2']}而不是{'h2': ['d3'], 'h1': ['d2']}

然后，我们将字典从最里面开始向外增长。这是通过迭代外部字典的键，并将每个值替换为由该值键控的dict，值是来自内部dict的键值对来实现的。

Answer 3

也许你应该试着简化你的代码？试试这个：

def pack_to_tree(*lists):

    split_ = lambda l: (i.split('_',1) for i in l)

    # last level
    result = {}
    for k, v in split_(lists[-1]):
        result.setdefault(k, []).append(v)

    # other levels
    for d in lists[-2::-1]:
        subresult = {}
        for k, v in split_(d):
            subresult.setdefault(k, {})[v] = result[v]
        result = subresult
    return result

a = ['t1_h1', 't2_h2']
b = ['h1_d1', 'h1_d2', 'h2_d3']
c = ['d1_dom1', 'd2_dom2', 'd3_dom3']
d = ['dom1_a', 'dom1_b', 'dom2_a', 'dom2_b', 'dom3_a', 'dom3_b']

print pack_to_tree(a, b, c, d)