Python嵌套字典深度合并技巧

本文针对Python中嵌套字典的深度合并问题，提出了一种基于`collections.ChainMap`的创新解决方案。`ChainMap`虽能合并字典，但无法处理嵌套结构。为此，我们自定义了`DeepChainMap`类，重写`__getitem__`方法，实现了递归合并嵌套字典的功能。通过示例展示了`DeepChainMap`在多层级字典合并中的优势，能够确保所有层级的同名键值都被妥善整合。同时，文章还分析了合并顺序、性能考量以及适用场景，并与`dict.update()`方法进行了对比，为开发者提供了深度合并嵌套字典的实用技巧和参考。

1. collections.ChainMap简介与局限性

collections.ChainMap是Python标准库collections模块中的一个类，它将多个字典或映射（mapping）组合成一个单一的可更新视图。当访问ChainMap中的键时，它会按照字典的顺序从左到右查找，返回第一个找到的值。这对于需要按优先级查找键值对的场景非常有用，例如配置管理。

基本用法示例：

from collections import ChainMap

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

chained_map = ChainMap(dict1, dict2)
print(chained_map['a']) # 输出: 1
print(chained_map['b']) # 输出: 2 (来自dict1，因为dict1在前面)
print(chained_map['c']) # 输出: 4
print(dict(chained_map)) # 输出: {'b': 2, 'c': 4, 'a': 1}

然而，ChainMap在处理嵌套字典的合并时存在一个显著的局限性。如果多个字典中存在相同的键，且这些键对应的值本身也是字典，ChainMap只会返回第一个字典中对应的值（即整个嵌套字典），而不会尝试将这些嵌套字典进行合并。

问题场景示例：

假设我们有两个嵌套字典a和b：

a = {'123': {'player': 1, 'opponent': 2},
     '18': {'player': 10, 'opponent': 12}}

b = {'123': {'winner': 1},
     '180': {'winner': 2}}

我们期望的合并结果是：

{'123': {'player': 1, 'opponent': 2, 'winner': 1},
 '18': {'player': 10, 'opponent': 12},
 '180': {'winner': 2}}

如果直接使用ChainMap(a, b)并转换为字典，结果将是：

from collections import ChainMap
print(dict(ChainMap(a, b)))
# 输出: {'123': {'player': 1, 'opponent': 2}, '180': {'winner': 2}, '18': {'player': 10, 'opponent': 12}}

可以看到，键'123'对应的值只保留了a中的内容，b中'123'下的'winner': 1丢失了。这正是ChainMap的默认行为：对于重复的键，它只返回最先遇到的那个值，而不会深入到值内部进行合并。

2. 构建自定义DeepChainMap实现深度合并

为了解决ChainMap无法深度合并嵌套字典的问题，我们需要创建一个自定义类DeepChainMap，继承自ChainMap，并重写其核心方法，特别是__getitem__。__getitem__方法定义了当通过键访问ChainMap实例时其行为方式。

核心思路：

重写的__getitem__方法需要实现以下逻辑：

1. 遍历ChainMap内部的所有映射（即传入的字典）。
2. 收集所有映射中对应给定键的值。
3. 如果第一个找到的值是字典类型，则递归地使用这些字典值来创建一个新的DeepChainMap实例，从而实现深度合并。
4. 如果第一个找到的值不是字典类型，则直接返回该值。

DeepChainMap实现代码：

from collections import ChainMap

class DeepChainMap(ChainMap):
    """
    一个ChainMap的变体，能够递归地合并嵌套的字典结构。
    """
    def __getitem__(self, key):
        """
        重写__getitem__方法，实现深度合并逻辑。
        """
        # 收集所有映射中对应key的值
        # 使用生成器表达式以节省内存，只在需要时获取值
        values = (mapping[key] for mapping in self.maps if key in mapping)

        try:
            # 获取第一个找到的值
            first = next(values)
        except StopIteration:
            # 如果所有映射中都没有找到该键，则调用父类的__missing__方法处理
            # 默认会抛出KeyError
            return self.__missing__(key)

        # 检查第一个值是否为字典类型
        if isinstance(first, dict):
            # 如果是字典，则递归地使用DeepChainMap来合并它和后续找到的字典
            # self.__class__在这里指向DeepChainMap自身
            return self.__class__(first, *values)

        # 如果不是字典，则直接返回第一个找到的值
        return first

    def __repr__(self):
        """
        重写__repr__方法，使DeepChainMap实例在打印时显示为常规字典的表示形式，
        方便调试和查看结果。
        """
        return repr(dict(self))

代码解析：

• __getitem__(self, key):
  • values = (mapping[key] for mapping in self.maps if key in mapping): 这是一个生成器表达式，它遍历self.maps（ChainMap内部存储所有字典的列表），并为每个包含key的字典提取对应的值。这样做的好处是只有在迭代时才计算值，而不是一次性创建所有值的列表。
  • try...except StopIteration: 尝试从values生成器中获取第一个值。如果生成器为空（即所有映射中都没有找到key），则捕获StopIteration异常，并调用self.__missing__(key)。ChainMap的__missing__方法默认会抛出KeyError，与标准字典行为一致。
  • if isinstance(first, dict):: 这是实现深度合并的关键。如果第一个找到的值first是字典类型，说明可能存在需要深度合并的嵌套结构。
  • return self.__class__(first, *values): 在这种情况下，我们递归地创建一个新的DeepChainMap实例。新的DeepChainMap将以first（第一个找到的字典）作为其第一个映射，然后将*values（所有后续找到的字典）作为其后续映射。这样，DeepChainMap会再次应用其__getitem__逻辑，从而实现对嵌套字典的深度合并。
• __repr__(self):
  • return repr(dict(self)): 这个方法是为了让DeepChainMap实例在被print()或在交互式环境中显示时，能够以一个常规字典的形式呈现，而不是DeepChainMap(...)的默认表示，这使得输出结果更直观易读。

3. DeepChainMap使用示例

现在，我们可以使用我们自定义的DeepChainMap类来解决最初的嵌套字典合并问题。

from collections import ChainMap

# 定义原始字典
a = {'123': {'player': 1,
             'opponent': 2},
     '18': {'player': 10,
            'opponent': 12}
    }

b = {'123': {'winner': 1},
     '180': {'winner': 2}
    }

# 使用DeepChainMap进行深度合并
deep_merged_dict = DeepChainMap(a, b)

# 打印合并后的结果
print(deep_merged_dict)

输出结果：

{'123': {'winner': 1, 'player': 1, 'opponent': 2}, '180': {'winner': 2}, '18': {'player': 10, 'opponent': 12}}

可以看到，对于键'123'，a和b中的嵌套字典被成功地合并了。'winner': 1来自b，而'player': 1, 'opponent': 2来自a，并且它们都被整合到了同一个字典中。其他不冲突的键（如'18'和'180'）也按预期保留。

4. 注意事项与总结

• 合并顺序： DeepChainMap继承了ChainMap的查找顺序特性。当多个字典中存在相同的键，且其值是非字典类型时，或在嵌套字典合并时，如果内部键也重复，则靠前的字典中的值会优先被保留。例如，在{'player': 1, 'opponent': 2}和{'winner': 1}合并时，如果b在a之前，那么winner会先被处理，然后player和opponent会被添加到结果中。在上述示例中，DeepChainMap(a, b)意味着a的优先级高于b。对于'123'键，a中的{'player': 1, 'opponent': 2}是第一个被发现的字典，然后b中的{'winner': 1}被递归地合并进去。
• 性能考量： 对于非常深或非常宽的嵌套字典结构，递归地创建DeepChainMap实例可能会带来一定的性能开销。在处理极端情况时，应评估其性能影响。
• 适用场景： DeepChainMap特别适用于需要将多个配置源（例如，默认配置、用户配置、运行时参数）以层级方式合并，并且希望在不同层级之间深度合并嵌套配置项的场景。
• 与dict.update()的区别： dict.update()方法可以用来合并字典，但它默认是浅合并。如果键对应的值是字典，update()会直接替换整个嵌套字典，而不是合并其内容。DeepChainMap则提供了更精细的深度合并控制。

通过自定义DeepChainMap，我们成功扩展了collections.ChainMap的功能，使其能够优雅地处理复杂的嵌套字典深度合并问题。这种方法利用了Python的面向对象特性和ChainMap的链式查找机制，提供了一个清晰且可维护的解决方案。

本篇关于《Python嵌套字典深度合并技巧》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！