Python中使用pickle序列化时如何保留对象引用关系？

以下是可落地的几种解决方案，按照适配成本从低到高排序：

方案1：使用pickle原生的persistent_id机制实现引用共享 #

这是Python官方专门为跨序列化上下文、避免全量序列化设计的特性，原理是自定义序列化时对需要共享引用的对象返回唯一标识，反序列化时根据标识从当前运行环境获取对应实例，不会生成重复对象，不需要改动现有业务类代码。
示例实现：

import pickle
import uuid

# 全局对象注册表，实际使用可以按业务域拆分，避免全局污染
object_registry = {}

# 业务类示例（你的原有代码不需要修改）
class Point:
    def __init__(self):
        self.id = uuid.uuid4().hex # 建议加业务稳定唯一ID，线上不要用内存id
        self.nearest_point = None
class Line:
    def __init__(self, pointA, pointB):
        self.pointA = pointA
        self.pointB = pointB

# 自定义序列化器
class CustomPickler(pickle.Pickler):
    def persistent_id(self, obj):
        # 对属于需要共享引用的类型，返回唯一ID，其他对象走默认序列化
        if isinstance(obj, (Point, Line)):
            object_registry[obj.id] = obj
            return obj.id
        return None

# 自定义反序列化器
class CustomUnpickler(pickle.Unpickler):
    def persistent_load(self, pid):
        # 反序列化时直接从注册表拿运行时的现有实例，不生成新对象
        return object_registry[pid]

# 测试流程
p1 = Point()
p2 = Point()
p1.nearest_point = p2
p2.nearest_point = p1
line = Line(p1, Point())
# 提前把运行时已有的line的pointA存入注册表
object_registry[line.pointA.id] = line.pointA

with open("pickled", "wb") as file:
    pickler = CustomPickler(file)
    pickler.dump(p1)
    pickler.dump(p2)

with open("pickled", "rb") as file:
    unpickler = CustomUnpickler(file)
    p1_new = unpickler.load()
    p2_new = unpickler.load()

# 两个断言都能通过
assert p1_new.nearest_point == p2_new
assert line.pointA == p1_new

方案2：自定义类的序列化逻辑 #

如果不想维护全局序列化器，可以在业务类里重写__getstate__和__setstate__方法，序列化时只存对象的业务属性+外部引用的唯一标识，反序列化时主动从当前运行上下文拉取对应引用实例。
示例：

class Point:
    def __init__(self):
        self.id = uuid.uuid4().hex
        self.nearest_point = None
        # 其他业务属性...
    
    def __getstate__(self):
        # 序列化时，只存自身ID和nearest_point的ID，不序列化整个引用对象
        state = self.__dict__.copy()
        if self.nearest_point:
            state["nearest_point_id"] = self.nearest_point.id
            del state["nearest_point"]
        return state
    
    def __setstate__(self, state):
        # 反序列化时，从全局业务索引里找对应的nearest_point实例
        self.__dict__.update(state)
        if "nearest_point_id" in state:
            # global_point_index是你业务侧维护的所有Point实例的索引表
            self.nearest_point = global_point_index[state["nearest_point_id"]]
            del self.nearest_point_id

方案3：统一序列化根节点 #

如果不想改序列化逻辑，可以梳理出整个对象图的唯一根节点，直接序列化根节点即可：pickle会自动遍历整个引用链，保证所有引用关系不变，不会出现重复实例。
你提到的全量序列化容易出疏漏，本质是没有找对根节点，只要确保根节点能触达所有需要保留引用的对象，不需要手动逐个dump，单次dump根节点就能解决问题。比如你的示例里，line就是根节点，只要执行pickler.dump(line)，p1、p2都会被自动序列化，反序列化后所有引用关系完全保留，不需要单独dump p1和p2。

注意事项 #

• 不要对同一个对象图的不同节点分开多次dump，多次dump会导致pickle丢失跨dump的引用关系，单次dump根节点是最省心的做法
• 线上环境不要用内存地址id()做唯一标识，内存地址每次进程启动都会变，要用业务主键、UUID等稳定的唯一标识
• 注册表需要做好生命周期管理，不用的对象要及时清理，避免内存泄漏

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