Python 技巧：高效反转嵌套字典，避免内存溢出_技术教程

本文旨在解决在 Python 中反转大型嵌套字典时可能出现的内存问题。我们将探讨如何利用生成器和自定义字典类 ReverseDict，以实现高效且节省内存的反转操作，避免一次性加载整个字典到内存中。

在处理大型数据集时，反转嵌套字典可能会导致内存溢出。传统的反转方法通常需要将整个字典加载到内存中，这对于包含数 GB 数据的字典来说是不可行的。本文将介绍一种更高效的方法，使用生成器和自定义字典类来避免内存问题。

问题背景

假设我们有一个嵌套字典，其中 dict1 包含 dict2，目标是将嵌套关系反转，即 dict2 包含 dict1。例如：

d0 = {
    'Bob': {'item1': 3, 'item2': 8, 'item3': 6},
    'Jim': {'item1': 6, 'item4': 7},
    'Amy': {'item1': 999, 'item2': 5, 'item3': 9, 'item4': 2}
}

我们希望将其转换为：

{
    'item1': {'Bob': 3, 'Jim': 6, 'Amy': 999},
    'item2': {'Bob': 8, 'Amy': 5},
    'item3': {'Bob': 6, 'Amy': 9},
    'item4': {'Jim': 7, 'Amy': 2}
}

解决方案：使用 ReverseDict 类

为了避免将整个反转后的字典存储在内存中，我们可以创建一个自定义字典类 ReverseDict，它只在需要时才计算反转后的值。这个类继承自 collections.UserDict，并重写了一些关键方法，例如 __getitem__、__iter__、keys、items 和 values。

from collections import UserDict


class ReverseDict(UserDict):
    def __init__(self, d: dict) -> None:
        # We set data here so that UserDict has access to underlying data
        self.data = d

    def __getitem__(self, key):
        # Overload this method to allow for reverse dict lookup
        result = {}
        for k, v in self.data.items():
            if key in v:
                result[k] = v[key]
        return result

    def __iter__(self):
       # This is necessary to be able to loop over the dict
       return iter(self.keys())

    def keys(self):
        # We modify this to return the reverse dict keys
        reversed_dict_keys = set()
        for k in self.data:
            for k in self.data[k]:
                reversed_dict_keys.add(k)
        return reversed_dict_keys

    def items(self):
        # We modify this to return the reverse dict items as a generator
        return ((k, self[k]) for k in self.keys())

    def values(self):
        # We modify this to return the reverse dict values as a generator
        return (self[k] for k in self.keys())

代码解释:

__init__: 初始化 ReverseDict 对象，将原始字典存储在 self.data 中。
__getitem__: 当使用 rd[key] 访问反转字典时，此方法会被调用。它遍历原始字典，查找包含指定 key 的所有内部字典，并将结果以字典形式返回。这样，只有在访问特定键时，才会计算相应的值，避免了加载整个反转字典到内存中。
__iter__: 返回反转字典的键的迭代器，允许我们遍历反转字典的键。
keys: 返回反转字典的所有键的集合。它遍历原始字典，收集所有内部字典的键，并返回一个集合。
items: 返回一个生成器，生成反转字典的键值对。
values: 返回一个生成器，生成反转字典的所有值。

使用示例

if __name__ == "__main__":
    d = {
        'Bob': {'item1': 3, 'item2': 8, 'item3': 6},
        'Jim': {'item1': 6, 'item4': 7},
        'Amy': {'item1': 999, 'item2': 5, 'item3': 9, 'item4': 2}
    }
    rd = ReverseDict(d)
    for k,v in rd.items():
        print(k, v)
    for k in rd:
        print(k)
    print(rd.keys())
    print(rd.values())
    print(rd.items())

输出:

item1 {'Bob': 3, 'Jim': 6, 'Amy': 999}
item2 {'Bob': 8, 'Amy': 5}
item3 {'Bob': 6, 'Amy': 9}
item4 {'Jim': 7, 'Amy': 2}
item1
item2
item3
item4
{'item1', 'item2', 'item3', 'item4'}
. at 0x000001E2530E5AC0>
. at 0x000001E2530E5AC0>