Python中深度合并嵌套字典的技巧：使用自定义ChainMap实现

在Python编程中，我们经常需要合并多个字典。对于简单的字典合并，Python提供了多种方法，例如使用dict.update()、字典解包运算符**或collections.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}}

可以看到，键'123'对应的内层字典被合并了，而其他非重叠的键则被保留。

collections.ChainMap 的局限性

collections.ChainMap是Python标准库中一个非常实用的工具，它允许我们将多个字典或映射组合成一个单一的、可更新的视图。当查找一个键时，ChainMap会按照传入字典的顺序，返回第一个包含该键的字典中的值。

让我们尝试使用ChainMap来合并上述字典：

立即学习“Python免费学习笔记（深入）”；

from collections import ChainMap

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

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

# 使用ChainMap
merged_chainmap = ChainMap(a, b)
print(dict(merged_chainmap))

输出结果为：

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

从结果可以看出，ChainMap在遇到键'123'时，仅仅返回了字典a中对应的值{'player': 1, 'opponent': 2}，而忽略了字典b中键'123'对应的{'winner': 1}。这是因为ChainMap默认执行的是浅层合并，它只关心顶层键的存在性，而不对键对应的复杂值（如嵌套字典）进行递归处理。

实现自定义深度合并的 DeepChainMap

为了实现深度合并，我们需要扩展ChainMap的功能，使其在遇到嵌套字典时能够递归地进行合并。这可以通过重写ChainMap的__getitem__方法来实现。__getitem__方法定义了当我们使用方括号[]访问ChainMap实例中的元素时的行为。

以下是实现深度合并的DeepChainMap类：

from collections import ChainMap

class DeepChainMap(ChainMap):
    """
    ChainMap的变体，支持深度合并嵌套字典。
    当访问一个键时，如果其值是字典，则递归地将所有映射中
    该键对应的字典值合并为一个新的DeepChainMap视图。
    """
    def __getitem__(self, 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)

        # 如果第一个值是字典类型，则递归地创建新的DeepChainMap实例进行深度合并
        if isinstance(first, dict):
            # 将第一个字典作为第一个映射，后续找到的所有字典作为后续映射
            return self.__class__(first, *values)

        # 如果不是字典类型，则直接返回第一个找到的值（遵循ChainMap的默认行为）
        return first

    def __repr__(self):
        # 重写__repr__方法，使其打印时更像一个常规字典，方便调试和查看结果
        return repr(dict(self))

__getitem__ 方法详解：

1. values = (mapping[key] for mapping in self.maps if key in mapping): 这一行是一个生成器表达式，它遍历DeepChainMap内部存储的所有原始字典（self.maps）。对于每个包含当前key的字典，它会提取出key对应的值。这样，values就成了一个包含所有层级上key对应值的迭代器。
2. try...except StopIteration: 尝试从values迭代器中获取第一个值（first）。如果迭代器为空（即没有任何一个原始字典包含该key），则捕获StopIteration异常，并调用self.__missing__(key)，这通常会触发KeyError，与标准字典行为保持一致。
3. if isinstance(first, dict):: 这是实现深度合并的关键。如果first（即找到的第一个值）是一个字典，这意味着我们需要对其进行深度合并。
4. *`return self.class(first, values)**: 在这种情况下，我们递归地创建一个新的DeepChainMap实例。新的DeepChainMap将first字典作为其第一个映射，并将values迭代器中剩余的所有字典作为后续映射。这个新的DeepChainMap`实例将负责合并这些内层字典，从而实现了递归合并的效果。
5. return first: 如果first不是字典（例如，它是一个整数、字符串或列表等），则不需要进行深度合并，直接返回first即可，这与ChainMap的默认行为一致。

__repr__ 方法详解：

为了使DeepChainMap实例在被打印时能显示为我们期望的合并后的字典形式，我们重写了__repr__方法。repr(dict(self))将DeepChainMap对象转换为一个常规字典，然后返回其字符串表示，这使得输出更加直观。

使用示例

现在，让我们使用自定义的DeepChainMap来合并之前的字典a和b：

# 原始字典
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'对应的内层字典{'player': 1, 'opponent': 2}和{'winner': 1}被成功地合并成了{'winner': 1, 'player': 1, 'opponent': 2}。同时，非重叠的键'18'和'180'也被正确地保留下来。

注意事项与总结

• 视图特性：DeepChainMap与ChainMap一样，提供的是一个合并后的视图，而不是创建一个全新的物理字典。这意味着对原始字典的修改会实时反映在DeepChainMap中。
• 读取操作：此DeepChainMap主要优化了读取操作（通过__getitem__）以实现深度合并。如果需要对深度合并后的视图进行写入（__setitem__）或删除（__delitem__）操作，并且希望这些操作能够影响到正确的原始字典层级，则需要进一步重写__setitem__和__delitem__方法，这会比__getitem__复杂，因为需要决定修改哪个原始字典。对于本教程的需求，我们主要关注读取时的深度合并。
• 性能：对于非常深或非常宽的嵌套字典，每次访问都可能创建新的DeepChainMap实例，这在某些极端情况下可能会有轻微的性能开销。但在大多数常见场景下，这种开销是可接受的。

通过自定义DeepChainMap，我们成功地克服了collections.ChainMap在处理嵌套字典时深度合并的局限性。这种方法提供了一种优雅且Pythonic的方式来创建多个字典的统一视图，尤其适用于配置管理、数据聚合等需要多层级数据合并的场景。

以上就是Python中深度合并嵌套字典的技巧：使用自定义ChainMap实现的详细内容，更多请关注php中文网其它相关文章！