Python嵌套字典反转优化：大内存场景下的实现问题求助

我正在尝试反转嵌套字典结构：将「外层键（如人名）对应内层字典（物品-数值映射）」的形式，转换为「内层键（如物品名）对应外层键（人名）-数值映射」的形式。

生成嵌套字典的类结构 #

嵌套字典由以下类结构生成：

# my_object0的所有函数与属性
class my_class0(object):
    def __init__(self, input, **kwargs):
        self.my_listA = ()
        ...

    def my_function0(self, **kwargs):
        for key, value in my_class(kwargs).my_function(kwargs):
            self.my_listA = ( (key2, value2) for key2, value2 in value.items() )
            ...
            if hasattr(self, key):
                yield from getattr(self, key)

    @property
    def my_property(self):
        for key, value in self.my_listA:
            yield key, value


# 查询object0信息的类（what?）
class my_class(object):
    def __init__(self, **kwargs):
        ...
        self.my_listB = []

    def my_function(self, **kwargs):
        my_list3 = []
        for key, value in my_class3(kwargs).my_function3(kwargs3):
            ...
            my_list3.append(value)
        self.my_listB = my_list3
        yield from self.my_functionZ(kwargsZ)  # 问题在这里！需要返回反转后的结构，而非原结构

    def my_functionZ(self, **kwargs):
        for key, value in my_class2(kwargs).my_function2(kwargs2):
            ...
            yield key, value


# 查询数据的类（where?）
class my_class2(object):
    def __init__(self, **kwargs):
        ...
    def my_function2(self, my_list2, **kwargs):
        for item2 in my_list2:  # my_list2 = dir(self)
            ...
            yield item2, getattr(self, item2)(self)

    def item2(self, self2, **kwargs):
        if call1:
            return "my_data1"
        elif call2:
            return "my_data2"
        ...
...

if __name__ == '__main__':
    ...
    for item in my_list:
        print( dict( my_class0(item).my_function0() ) )

已实现的基础反转函数 #

我先实现了一个可以正确反转的函数，但仅适用于小数据量：

def flip_dict_in_dict1(generator1):
    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})
)

正确反转结果 #

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

内存瓶颈与尝试方案 #

当嵌套字典数据量在1KB至10GB范围时，无法将完整的dict3存入内存。因此我尝试自定义字典类，希望通过懒加载避免内存占用，但未能正确配置__contains__、__getitem__、__iter__等方法使其正常工作：

class flip_dict_in_dict2(dict):
    def __init__(self, mirror):
        self.mirror = mirror
        self.dict2 = self.mirroir_dict2
    def __contains__(self, key3) -> bool:
        return self.dict2(self, key3)
    def __getitem__(self, key):
        return self.dict2(self, key)
    def __iter__(self) -> Iterator:
        return iter( self.dict2(self) )
    class mirroir_dict2(dict):
        def __init__(self, parent, key1):
            self.parent = parent
            self.key1 = key1
        def __contains__(self, key2) -> bool:
            print( self.key1, key2 )
            return key2 in self.parent.mirror
        def __getitem__(self, key2):
            return self.parent.mirror[key2][self.key1]
        def __iter__(self) -> Iterator:
            print("****")
            for value in self.parent.mirror.values():
                yield value

寻求帮助 #

需要完善上述自定义字典类，或提供更节省CPU与内存、无需自定义类的替代方案，同时欢迎对现有代码架构提出改进建议。

内容的提问来源于stack exchange，提问作者user23174060