Python高效反转大型嵌套字典：基于UserDict的内存优化实现

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}}

def flip_dict_in_dict_simple(original_data):
    reversed_dict = {}
    for outer_key, inner_dict in original_data.items():
        for inner_key, value in inner_dict.items():
            reversed_dict.setdefault(inner_key, {})[outer_key] = value
    return reversed_dict

# 示例使用
d0 = {
    'Bob': {'item1': 3, 'item2': 8, 'item3': 6},
    'Jim': {'item1': 6, 'item4': 7},
    'Amy': {'item1': 999, 'item2': 5, 'item3': 9, 'item4': 2}
}
print(flip_dict_in_dict_simple(d0))

from collections import UserDict
from typing import Iterator, Dict, Any

class ReverseDict(UserDict):
    """
    一个提供嵌套字典反转视图的只读字典类。
    它不实际存储反转后的字典，而是按需从原始字典中提取数据。
    """
    def __init__(self, original_dict: Dict[Any, Dict[Any, Any]]) -> None:
        """
        初始化ReverseDict。
        Args:
            original_dict: 原始的嵌套字典，例如 {'外层键': {'内层键': 值}}
        """
        # UserDict 将其底层数据存储在 self.data 中
        self.data = original_dict

    def __getitem__(self, key: Any) -> Dict[Any, Any]:
        """
        重写 __getitem__ 方法，实现按内层键查找。
        当访问 ReverseDict[inner_key] 时，动态构建一个字典，
        包含所有原始字典中对应的 outer_key: value 对。
        """
        result = {}
        # 遍历原始字典，查找所有包含 'key' 作为内层键的项
        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[Any]:
        """
        重写 __iter__ 方法，允许直接迭代 ReverseDict。
        迭代时返回的是反转后的字典的“外层键”（即原始字典的“内层键”）。
        """
        return iter(self.keys())

    def keys(self) -> Iterator[Any]:
        """
        返回一个生成器，生成反转后字典的所有键（即原始字典的所有内层键）。
        """
        reversed_dict_keys = set()
        for outer_key in self.data:
            for inner_key in self.data[outer_key]:
                reversed_dict_keys.add(inner_key)
        # 使用生成器而不是直接返回列表，以节省内存
        yield from reversed_dict_keys

    def items(self) -> Iterator[tuple[Any, Dict[Any, Any]]]:
        """
        返回一个生成器，生成反转后字典的所有 (键, 值) 对。
        每个值都是通过 __getitem__ 动态获取的字典。
        """
        # 遍历所有反转后的键，并使用 __getitem__ 获取对应的值
        return ((k, self[k]) for k in self.keys())

    def values(self) -> Iterator[Dict[Any, Any]]:
        """
        返回一个生成器，生成反转后字典的所有值。
        每个值都是通过 __getitem__ 动态获取的字典。
        """
        # 遍历所有反转后的键，并使用 __getitem__ 获取对应的值
        return (self[k] for k in self.keys())

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

    rd = ReverseDict(d0)

    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(list(rd.keys())) # 转换为列表以便打印

    print("\n--- 获取所有值 (values()) ---")
    # 注意：values() 返回的是生成器，直接打印是生成器对象，需要迭代或转换为列表
    for v_dict in rd.values():
        print(v_dict)

    print("\n--- 按键访问 (__getitem__) ---")
    print(f"rd['item1']: {rd['item1']}")
    print(f"rd['item2']: {rd['item2']}")
    print(f"rd['item4']: {rd['item4']}")

--- 迭代 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()) ---
['item1', 'item2', 'item3', 'item4']

--- 获取所有值 (values()) ---
{'Bob': 3, 'Jim': 6, 'Amy': 999}
{'Bob': 8, 'Amy': 5}
{'Bob': 6, 'Amy': 9}
{'Jim': 7, 'Amy': 2}

--- 按键访问 (__getitem__) ---
rd['item1']: {'Bob': 3, 'Jim': 6, 'Amy': 999}
rd['item2']: {'Bob': 8, 'Amy': 5}
rd['item4']: {'Jim': 7, 'Amy': 2}