1

我有一个数据列表，我正在从中创建 dict

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' 值丢失

4

5 回答 5

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_dictdict通过将输入字符串拆分为键和值来返回 a 。很酷的一点是，通过使用defaultdict我们可以轻松地将其他键值附加到键，而无需进行任何检查，即：

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

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

于 2012-06-11T13:08:11.537 回答
1

也许您应该尝试简化代码？试试这个：

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)
于 2012-06-11T13:06:50.220 回答
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']}}}}
于 2012-06-11T13:10:10.677 回答
0

阅读该代码相当困难，但我认为在您创建新字典 ( ...={}) 尤其是新链表 ( ...=[]) 的行中，您应该尝试以下操作：

if (not  f[item.split('_')[0]][item.split('_')[1]][hypercube.split('_')[1]][dimension.split('_')[1]]):
   f[item.split('_')[0]][item.split('_')[1]][hypercube.split('_')[1]][dimension.split('_')[1]]=[]
f[item.split('_')[0]][item.split('_')[1]][hypercube.split('_')[1]][dimension.split('_')[1]].append(domain.split('_')[1])

然后你确定你没有覆盖已经存在的东西。

于 2012-06-11T12:55:37.780 回答
0

样式问题已经提到过，所以我专注于功能。原始代码中的简单错误在最后一行。由于字典键序列的第一次出现只是分配了一个空列表，因此重要的值

domain.split('_')[1]

丢失了。所以实际上没有覆盖，但从未存储过缺失值。用这个术语填充空方括号应该可以解决这个问题。

于 2012-06-11T13:41:41.117 回答