在 Python 中更改嵌套字典中键的值

Question

我在更新嵌套字典中的值时遇到了一些问题。

my_dic = {'TypeA': {'Bit0': {'TypeA': {'Bit0': 'A', 'Bit1': 'B', 'Bit2' : 'C'}, 'TypeB': 'D', 'TypeC': 'E'}, 'Bit1': 'F', 'Bit2': 'G'}, 'TypeB': 'H'}

我需要用新字典更新具有值 A、B 和 C 的字典

new_dic = {Sensor Error: {'Bit0' : 'X', 'Bit1': 'Y', 'Bit2': 'Z'}}

我不想要一个新功能来做这件事。这出现在我需要更新字典的处理中的某个地方。这可以使用while循环或for循环来完成吗？经历了其他堆栈溢出问题。找不到这样的东西。所有这些问题都有一个功能，并且最多在字典的两层内迭代。字典在这里可以有任何深度。

def recursive_lookup(k, d):
if k in d: return d[k]
for v in d.values():
    if isinstance(v, dict):
        a = recursive_lookup(k, v)
        if a is not None: return a
return None

尝试了这段代码，发现这对任何深度都不起作用。另外，这不符合我的要求。我不需要函数来查找键并替换它的值。

详细来说，字典基本上都是错误和错误词。

my_dic = {
          'System Error': {
                           'Bit0': 'Out of Sync'
                           'Bit1': {
                                    'Sensor Error':{                                              
                                                    'Bit0': 'Out of Range Error'
                                                    'Bit1': 'Communication Error'
                                                   }
                                    }
                            'Bit2': 'System Unresponsive Error'
                            }
          }

这是my_dic的应用

期望的输出是：

my_dic = {
              'System Error': {
                               'Bit0': 'Out of Sync'
                               'Bit1': {
                                        'Sensor Error':{                                              
                                                        'Bit0': 'X'
                                                        'Bit1': 'Y'
                                                        'Bit2': 'Z'
                                                       }
                                        }
                                'Bit2': 'System Unresponsive Error'
                                }
              }

Answer 1

您的示例 my_dic 如下所示。所以你的查找k 是"TypeA"？但是还有一个 "Bit0" 键嵌套在第一级 "TypeA" 字典中。对此有何规定？我不理解您在此处尝试实现的“查找规则”。

{
    "TypeA": {
        "Bit0": {
            "TypeA": {
                "Bit0": "A",
                "Bit1": "B",
                "Bit2": "C"
            },
            "TypeB": "D",
            "TypeC": "E"
        },
        "Bit1": "F",
        "Bit2": "G"
    },
    "TypeB": "H"
}

查找规则：

1. 第一级必须有密钥k（“TypeA”）
2. 二级可以有任意键，但必须是字典类型，舍弃所有非字典？
3. 第三级必须有密钥k（“TypeA”）？

Answer 2

因此，显然，根据计算机科学，递归函数可以转换为迭代循环，因此也许有一种方法可以在循环中完成您想要的。

另外，将不同的功能放入函数中通常更好，因为我喜欢递归函数匹配递归数据结构，这是我的解决方案。

请注意，您没有提供任何更新后数据结构的示例，所以我不得不猜测这部分。

这段代码：

def recursiveUpdate(target, keys, update):
    for k in target:
        if k in keys:
            v = target[k]
            if isinstance(v, dict):
                recursiveUpdate(v, keys, update)
            else:
                print(target[k], update[k])
                target[k] = update[k]
        else:
            v = target[k]
            if isinstance(v, dict):
                recursiveUpdate(v, keys, update)
                
my_dic = {
          'System Error': {
                           'Bit0': 'Out of Sync',
                           'Bit1': {
                                    'Sensor Error':{                                              
                                                    'Bit0': 'Out of Range Error',
                                                    'Bit1': 'Communication Error'
                                                   }
                                    },
                            'Bit2': 'System Unresponsive Error'
                            }
          }

new_dic = {'Bit0' : 'X', 'Bit1': 'Y', 'Bit2': 'Z'}

keys = list(new_dic.keys())
recursiveUpdate(my_dic, keys, new_dic)

print(my_dic)

产生这个输出：

{'System Error': {'Bit0': 'X', 'Bit1': {'Sensor Error': {'Bit0': 'X', 'Bit1': 'Y'}}, 'Bit2': 'Z'}}