如何通过id返回的内存地址访问Python对象？嵌套字典场景求解

关于通过内存地址访问对象的问题 #

首先明确：不建议直接通过内存地址获取Python对象，这会绕过Python的自动内存管理机制，可能引发对象已被GC回收、内存访问错误等问题。如果非要尝试，可借助ctypes实现，但风险极高，示例代码如下：

import ctypes

def get_obj_from_addr(addr):
    return ctypes.cast(addr, ctypes.py_object).value

上述代码仅作技术演示，绝对不要在生产环境中使用。

针对你的原始需求：嵌套字典+子字典依赖外层参数 #

你的核心需求是实现「外层字典存储特定子字典，子字典可调用依赖外层参数的方法」，同时避免迭代时的无限自引用问题。以下是两种更优雅的解决方案：

方案1：用弱引用避免循环引用 #

使用Python标准库的weakref模块创建外层字典的弱引用，弱引用不会阻止对象被GC回收，也不会形成强引用循环，从根源上解决迭代问题。

示例代码：

import weakref

class OuterDict(dict):
    def __setitem__(self, key, value):
        # 限制存入的必须是InnerDict类型
        if isinstance(value, InnerDict):
            # 给子字典绑定外层的弱引用
            value.outer_ref = weakref.ref(self)
        super().__setitem__(key, value)

class InnerDict(dict):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.outer_ref = None  # 初始化弱引用占位

    def evaluate(self):
        if not self.outer_ref:
            raise ValueError("该子字典未关联外层字典")
        outer = self.outer_ref()
        if not outer:
            raise ValueError("关联的外层字典已被回收")
        # 调用外层字典的parameter2参数
        param2 = outer.get("parameter2", 0)
        return sum(self.values()) * param2

# 使用示例
outer = OuterDict()
outer["parameter1"] = InnerDict(bla=42, blubb=15)
outer["parameter2"] = 2
print(outer["parameter1"].evaluate())  # 输出 (42+15)*2 = 114

# 迭代外层字典无循环引用问题
for k, v in outer.items():
    print(k, v)

方案2：重写迭代方法，排除父引用 #

如果需要保持强引用，可在子字典中重写迭代相关方法，主动排除保存父对象的属性，这样迭代时就不会触发无限循环。

示例代码：

class OuterDict(dict):
    def __setitem__(self, key, value):
        if isinstance(value, InnerDict):
            value.parent = self
        super().__setitem__(key, value)

class InnerDict(dict):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.parent = None

    def evaluate(self):
        if not self.parent:
            raise ValueError("该子字典未关联外层字典")
        param2 = self.parent.get("parameter2", 0)
        return sum(self.values()) * param2

    # 重写迭代方法，排除parent属性
    def __iter__(self):
        return (k for k in super().__iter__() if k != "parent")

    def keys(self):
        return list(self.__iter__())

    def items(self):
        return ((k, self[k]) for k in self.__iter__())

    def values(self):
        return (self[k] for k in self.__iter__())

# 使用示例
outer = OuterDict()
outer["parameter1"] = InnerDict(bla=42, blubb=15)
outer["parameter2"] = 2
print(outer["parameter1"].evaluate())  # 输出114

# 迭代子字典只会显示业务数据，不会出现parent
for k, v in outer["parameter1"].items():
    print(k, v)  # 仅打印bla:42、blubb:15

总结 #

• 绝对不要通过内存地址访问对象，这不符合Python的设计哲学，且存在严重安全隐患。
• 优先选择弱引用方案，既解决循环引用问题，又符合Python内存管理机制；若需强引用，重写迭代方法排除父引用也是可行方案。

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