Python嵌套字典反转：内存优化与只读视图实现

def flip_dict_in_dict_traditional(original_generator):
    """
    传统方法反转嵌套字典。
    该方法会构建并返回一个新的完整字典。
    """
    reversed_dict = {}
    for outer_key, inner_dict in original_generator:
        for inner_key, value in inner_dict.items():
            reversed_dict.setdefault(inner_key, {})[outer_key] = value
    return reversed_dict

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

# 使用传统方法
# 注意：这里需要将生成器转换为列表或迭代器，以便多次使用
# 如果d0_generator是真实的生成器，只能迭代一次
# 为演示，我们假设它是一个可重复迭代的结构，或在每次调用时重新创建
print(flip_dict_in_dict_traditional(d0_generator))

{'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:
        # UserDict需要一个名为data的属性来存储底层数据
        # 这里我们将原始字典作为data，以便UserDict的默认方法能够访问
        self.data = d

    def __getitem__(self, key: str) -> dict:
        """
        重载字典的__getitem__方法，实现反转字典的查找。
        当访问 rd[reversed_key] 时，它会遍历原始字典，
        收集所有与 reversed_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]:
        """
        重载字典的__iter__方法，使其能够迭代反转字典的键。
        """
        return iter(self.keys())

    def keys(self) -> set[str]:
        """
        返回反转字典的所有键（即原始字典中所有内部字典的键的集合）。
        """
        reversed_dict_keys = set()
        for inner_dict in self.data.values():
            for k in inner_dict.keys():
                reversed_dict_keys.add(k)
        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}
    }

    # 创建ReverseDict实例
    rd = ReverseDict(d)

    print("--- 迭代 items() ---")
    for k, v in rd.items():
        print(f"{k}: {v}")

    print("\n--- 直接迭代 ReverseDict (相当于迭代 keys()) ---")
    for k in rd:
        print(k)

    print("\n--- 获取 keys() ---")
    print(f"Keys: {rd.keys()}")

    print("\n--- 获取 values() ---")
    print(f"Values: {rd.values()}") # 注意这里会打印生成器对象本身

    print("\n--- 获取 items() ---")
    print(f"Items: {rd.items()}")   # 注意这里会打印生成器对象本身

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

--- 迭代 items() ---
item1: {'Bob': 3, 'Jim': 6, 'Amy': 999}
item2: {'Bob': 8, 'Amy': 5}
item3: {'Bob': 6, 'Amy': 9}
item4: {'Jim': 7, 'Amy': 2}

--- 直接迭代 ReverseDict (相当于迭代 keys()) ---
item1
item2
item3
item4

--- 获取 keys() ---
Keys: {'item1', 'item2', 'item3', 'item4'}

--- 获取 values() ---
Values: <generator object ReverseDict.values.<locals>.<genexpr> at 0x...>

--- 获取 items() ---
Items: <generator object ReverseDict.items.<locals>.<genexpr> at 0x...>

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