Python中反转嵌套字典：内存高效的视图实现

def flip_dict_in_dict(generator1):
    """
    将嵌套字典（或生成器）的键值对进行反转。
    例如：{'Bob': {'item1':3}} -> {'item1': {'Bob':3}}
    """
    dict3 = {}
    for key, val in generator1:
        for key2, val2 in val.items():
            dict3.setdefault(key2, {}).update({key: val2})
    return dict3

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

# 转换为生成器形式以模拟原始问题场景
d0_generator = (
    ('Bob', {'item1': 3, 'item2': 8, 'item3': 6}),
    ('Jim', {'item1': 6, 'item4': 7}),
    ('Amy', {'item1': 999, 'item2': 5, 'item3': 9, 'item4': 2})
)

# 执行反转
reversed_d0 = flip_dict_in_dict(d0_generator)
print(reversed_d0)

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

from collections import UserDict
from typing import Iterator

class ReverseDict(UserDict):
    """
    一个提供反转嵌套字典视图的类，通过按需计算避免全内存加载。
    当前实现为只读视图。
    """
    def __init__(self, d: dict) -> None:
        """
        初始化ReverseDict实例，存储原始字典的引用。
        """
        # UserDict基类需要访问底层数据，我们在此设置
        self.data = d

    def __getitem__(self, key: str) -> dict:
        """
        重载此方法以实现反转字典的键查找。
        当访问rd[key]时，它会遍历原始字典，查找所有内层字典中包含key的项，
        并构建一个新的字典作为结果。
        """
        result = {}
        for outer_key, inner_dict in self.data.items():
            if key in inner_dict:
                result[outer_key] = inner_dict[key]
        return result

    def __iter__(self) -> Iterator[str]:
        """
        使ReverseDict实例可迭代，迭代时返回反转字典的键。
        """
        return iter(self.keys())

    def keys(self) -> set[str]:
        """
        返回反转字典的所有键（即原始内层字典的所有唯一键）。
        """
        reversed_dict_keys = set()
        for outer_key in self.data:
            for inner_key in self.data[outer_key]:
                reversed_dict_keys.add(inner_key)
        return reversed_dict_keys

    def items(self) -> Iterator[tuple[str, dict]]:
        """
        返回反转字典的键值对，以生成器形式提供，避免一次性生成所有项。
        """
        return ((k, self[k]) for k in self.keys())

    def values(self) -> Iterator[dict]:
        """
        返回反转字典的所有值，以生成器形式提供，避免一次性生成所有值。
        """
        return (self[k] for k in self.keys())

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)

    print("--- 遍历反转字典的项 ---")
    for k, v in rd.items():
        print(f"{k}: {v}")

    print("\n--- 直接迭代反转字典（获取键） ---")
    for k in rd:
        print(k)

    print("\n--- 获取反转字典的所有键 ---")
    print(rd.keys())

    print("\n--- 获取反转字典的所有值（生成器） ---")
    print(rd.values())

    print("\n--- 获取反转字典的所有项（生成器） ---")
    print(rd.items())

    print("\n--- 访问特定反转键 ---")
    print(f"rd['item1']: {rd['item1']}")
    print(f"rd['item2']: {rd['item2']}")
    print(f"rd['item4']: {rd['item4']}")

--- 遍历反转字典的项 ---
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'}

--- 获取反转字典的所有值（生成器） ---
<generator object ReverseDict.values.<locals>.<genexpr> at 0x...>

--- 获取反转字典的所有项（生成器） ---
<generator object ReverseDict.items.<locals>.<genexpr> at 0x...>

--- 访问特定反转键 ---
rd['item1']: {'Bob': 3, 'Jim': 6, 'Amy': 999}
rd['item2']: {'Bob': 8, 'Amy': 5}
rd['item4']: {'Jim': 7, 'Amy': 2}