Question

input = { "a" : { "x": 1, "y": 2 },
     "b" : { "x": 3, "z": 4 } }
output = {'y': {'a': 2},
                'x': {'a': 1, 'b': 3},
                'z': {'b': 4} }

我需要根据输入创建一个新字典，它应该作为输出。到目前为止，我写了：

def pivot_nested_dict(nested_dict):
5       stateDict={}
6       for i in nested_dict:
7           dict2=nested_dict[i]
8           for j in dict2:
9               stateDict[j]= {i: dict2[j]}
10      return stateDict
11  
12  print pivot_nested_dict(input)

我几乎有答案，输出= {'y'：{'a'：2}，'x'：{'b'：3}，'z'：{'b'：4}}。因此，x键覆盖'a'：1。如何保持a和b？

Answer 1

如果没有复制字典，一旦更改了与给定密钥对应的值，就无法在字典上保留原始值。

例如，无论数据结构有多复杂，都会发生以下覆盖。

x = {'a':1}
x['a'] = 2
print x
>>> {'a': 2}

您可以复制它，但需要手动管理原始值。

x = {'a':1}
x,oldx = x,x.copy()
oldx['a'] = 2
print x, oldx
>>> {'a': 2} {'a': 1}

您可以利用以下事实：值可以是任何类型的结构，包括数组或字典，以存储每个连续的值更改。

Answer 2

您需要检查密钥是否已在stateDict中，如果是，则将新元素添加到嵌套字典中：

def pivot_nested_dict(nested_dict):
    stateDict = {}
    for i in nested_dict:
        dict2 = nested_dict[i]
        for j in dict2:
            if j not in stateDict:
                stateDict[j] = {i: dict2[j]}
            else:
                stateDict[j][i] = dict2[j]
    return stateDict

print pivot_nested_dict(inp)

Answer 3

我有这个小脚本你完成了你的工作注意：如果输入正确。

<强>码

output = {}
for d in input.items():
    for item in d:
        if type(item) == dict:
            for i in item.keys():
                d = {k:item[i]}
                output[i] = {k:item[i]} if not i in output.keys() else dict(output[i].items() + d.items())
        else: k=item

输入：

input = { "a" : { "x": 1, "y": 2 ,'z':15},"b" : { "x": 3, "z": 4 } }

<强>输出：

{'y': {'a': 2}, 'x': {'a': 1, 'b': 3}, 'z': {'a': 15, 'b': 4}}

希望这会有所帮助：）

Answer 4

我有这个

input = { "a" : { "x": 1, "y": 2 },
     "b" : { "x": 3, "z": 4 } }

output = {}

for k,v in zip(input.keys(), input.values()):
    for kk, vv in zip(v.keys(), v.values()):
        if kk in output.keys():
            output[kk][k] = vv
        else:
            output[kk] = {k : vv}

如何在不覆盖旧值的情况下更新字典中的键

4 个答案: