如何通过属性值获取类实例及优雅序列化跨实例属性关联

Python本身不会自动追踪所有已创建的类实例，所以要实现“通过属性值找实例”，最靠谱的方式是自己维护一个实例注册表。这里给你两种实用方案：

基础版：用列表保存实例 #

适合简单场景，缺点是实例被删除后列表仍会保留引用，可能引发内存泄漏：

class MyClass:
    # 类属性，存储所有实例
    _all_instances = []

    def __init__(self, name, target_attr):
        self.name = name
        self.target_attr = target_attr
        # 创建实例时自动加入注册表
        self._all_instances.append(self)

    @classmethod
    def get_instance_by_attr(cls, attr_value):
        # 遍历所有实例，匹配属性值
        for instance in cls._all_instances:
            if instance.target_attr == attr_value:
                return instance
        # 没找到返回None
        return None

# 测试
obj1 = MyClass("obj1", "test_val")
obj2 = MyClass("obj2", "other_val")
found_obj = MyClass.get_instance_by_attr("test_val")
print(found_obj.name)  # 输出 obj1

进阶版：用弱引用集合避免内存泄漏 #

如果你的实例会被动态删除，用weakref.WeakSet更安全——实例被垃圾回收时会自动从集合中移除：

import weakref

class MyClass:
    _all_instances = weakref.WeakSet()

    def __init__(self, name, target_attr):
        self.name = name
        self.target_attr = target_attr
        self._all_instances.add(self)

    @classmethod
    def get_instance_by_attr(cls, attr_value):
        for instance in cls._all_instances:
            if instance.target_attr == attr_value:
                return instance
        return None

你的场景里，in_obj.foo.value是out_obj.foo这个AttrClass实例，但AttrClass不知道自己属于哪个ObjClass，所以没法直接找到out_obj。我们可以给AttrClass加一个反向引用，再配合自定义序列化逻辑来解决：

第一步：给类添加反向引用 #

修改类结构，让AttrClass记录自己的所属ObjClass实例：

class AttrClass(object):
    def __init__(self, value=None, owner=None):
        self.value = value
        self.owner = owner  # 记录所属的ObjClass实例

class ObjClass(object):
    def __init__(self, name, value=None):
        self.name = name
        # 创建AttrClass时把自己作为owner传进去
        self.foo = AttrClass(value=value, owner=self)

现在你就能轻松从in_obj.foo.value找到out_obj了：

out_obj = ObjClass('out', value='bar')
in_obj = ObjClass('in', value=out_obj.foo)

# 找到关联的out_obj
found_out_obj = in_obj.foo.value.owner
print(found_out_obj.name)  # 输出 'out'

第二步：优雅序列化实例关联 #

如果需要序列化这些带引用的实例（比如存为JSON或pickle），直接序列化会有问题（比如JSON不支持对象引用）。这里给你一个基于唯一ID的自定义序列化方案：

import json
from uuid import uuid4

class AttrClass(object):
    def __init__(self, value=None, owner=None):
        self.id = str(uuid4())  # 给每个实例分配唯一ID
        self.value = value
        self.owner = owner

class ObjClass(object):
    def __init__(self, name, value=None):
        self.id = str(uuid4())
        self.name = name
        self.foo = AttrClass(value=value, owner=self)

# 序列化函数：把对象转成可JSON化的字典
def serialize(obj):
    if isinstance(obj, (ObjClass, AttrClass)):
        data = obj.__dict__.copy()
        # 如果属性是另一个实例，保存它的ID而不是对象本身
        if isinstance(data.get('value'), (ObjClass, AttrClass)):
            data['value'] = {'__ref_id__': data['value'].id}
        # 同样处理owner引用
        if data.get('owner'):
            data['owner'] = {'__ref_id__': data['owner'].id}
        # 标记对象类型，方便反序列化
        data['__type__'] = obj.__class__.__name__
        return data
    raise TypeError(f"无法序列化类型为 {type(obj)} 的对象")

# 反序列化函数：先创建所有对象，再重建引用
def deserialize(data):
    obj_map = {}
    
    # 第一步：先创建所有实例，不处理引用
    for item in data:
        if item['__type__'] == 'ObjClass':
            obj = ObjClass(item['name'])
            obj.id = item['id']
            obj_map[obj.id] = obj
        elif item['__type__'] == 'AttrClass':
            obj = AttrClass()
            obj.id = item['id']
            obj_map[obj.id] = obj
    
    # 第二步：填充属性和重建引用
    for item in data:
        obj = obj_map[item['id']]
        if item['__type__'] == 'ObjClass':
            obj.foo = obj_map[item['foo']['id']]
        elif item['__type__'] == 'AttrClass':
            obj.value = item['value']
            # 如果是引用ID，替换成实际对象
            if isinstance(obj.value, dict) and '__ref_id__' in obj.value:
                obj.value = obj_map[obj.value['__ref_id__']]
            if item['owner']:
                obj.owner = obj_map[item['owner']['__ref_id__']]
    
    # 返回反序列化后的对象（这里假设第一个是out_obj，第二个是in_obj）
    return obj_map[data[0]['id']], obj_map[data[1]['id']]

# 测试序列化和反序列化
out_obj = ObjClass('out', value='bar')
in_obj = ObjClass('in', value=out_obj.foo)

# 收集所有需要序列化的对象（实际场景可以写递归函数自动收集）
all_objs = [out_obj, in_obj, out_obj.foo, in_obj.foo]
serialized_data = [serialize(obj) for obj in all_objs]

# 转成JSON字符串
json_str = json.dumps(serialized_data)

# 反序列化
deserialized_out, deserialized_in = deserialize(json.loads(json_str))

# 验证关联是否保留
print(deserialized_in.foo.value.owner.name)  # 输出 'out'

这个方案既解决了实例关联的序列化问题，也能轻松反向查找关联的实例，代码结构也比较清晰。

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