Python pickle多层嵌套对象序列化仅存顶层结构的问题求助

核心问题根因 #

所有序列化数据丢失的问题，都不是pickle本身不支持多层嵌套，而是现有代码的写法存在三个明确的bug：

• 类属性与实例属性混用：Person.currentOrders、Order.items、Order.date全部被定义为类层级的可变属性，这类属性是所有实例共享的全局对象。当你在实例上修改这些属性的值、追加数据时，实际修改的是类共享的内存对象，序列化时很容易出现引用错位，加载时读不到实例上存的业务数据，只保留类定义的默认空值。
• 冗余的拆分式读写逻辑：现有save方法先dump整个技师对象，再单独dump一次技师的订单列表，load时又反过来读取并覆盖。Pickle本身天生支持递归序列化完整对象树，根本不需要手动拆分嵌套子对象做多次写入，这种写法反而容易因为读写顺序、内存引用的问题导致数据匹配错位。
• 零散的语法与结构错误：包括方法缺冒号、缩进错位、类名拼写错误（PeronContainer缺字母s）、测试代码调用不存在的类（LashTracking），这些问题会进一步导致运行行为和预期不一致。

可直接运行的规范实现 #

所有需要独立存储的业务属性全部下沉到__init__方法中定义为实例属性，去掉冗余的拆分读写，直接对顶层容器做一次全量序列化即可：

import pickle
import os
from datetime import datetime


class Order:
    def __init__(self, items):
        # 每个订单独立存储自己的属性，不共用类级别的可变对象
        self.date = datetime.now()
        self.items = {}
        for size, value in items.items():
            self.items[size] = value

    def toString(self):
        print("-------Order Item-------")
        print("Order Create Date:", self.date)
        for item_name, item_meta in self.items.items():
            print("Commodity Type: " + item_name)
            print("Quantity: " + str(item_meta[0]))
            print("Unit Price: " + str(item_meta[1]))
            print("------------------------")


class Person:
    def __init__(self, name):
        # 每个技师独立维护自己的订单列表，不共用类级别的空列表
        self.name = name
        self.currentOrders = []
        self.completedOrders = []

    def placeOrder(self, order):
        if len(self.currentOrders) > 0:
            print(f"{self.name} has pending unpaid orders!")
        self.currentOrders.append(order)
        print("Order successfully attached to technician.")

    def toString(self):
        print(f"\nTechnician Name: {self.name}")
        print("-"*30)
        print("Current pending orders:")
        for order in self.currentOrders:
            order.toString()
        print("\nCompleted orders:")
        for order in self.completedOrders:
            order.toString()


class PersonContainer(object):
    def __init__(self):
        # 容器自身维护的技师列表也设为实例属性，避免跨实例共享
        self.currentTechs = []

    def addTech(self, tech):
        self.currentTechs.append(tech)

    def save_objects(self, save_path="retail_order_dataset.pkl"):
        # 单次序列化整个容器对象，pickle会递归遍历所有嵌套的Person、Order实例完成全量持久化
        with open(save_path, 'wb') as output_file:
            pickle.dump(self, output_file, protocol=pickle.HIGHEST_PROTOCOL)

    def load_objects(self, save_path="retail_order_dataset.pkl"):
        # 单次读取全量持久化的容器对象，不需要拆分读取嵌套字段
        if not os.path.exists(save_path):
            return
        with open(save_path, 'rb') as input_file:
            loaded_container = pickle.load(input_file)
            self.currentTechs = loaded_container.currentTechs

    def toString(self):
        for tech in self.currentTechs:
            tech.toString()


if __name__ == '__main__':
    # 写入测试流程
    tech_jeremy = Person("Jeremy")
    tech_jeremy.placeOrder(Order({"Cotton Pad": (5, 7.40)}))
    tech_jeremy.placeOrder(Order({"Lash Glue": (2, 22.50)}))

    app_container = PersonContainer()
    app_container.addTech(tech_jeremy)
    app_container.toString()
    app_container.save_objects()

    # 加载恢复测试流程
    restore_container = PersonContainer()
    restore_container.load_objects()
    restore_container.toString()

关键注意事项 #

• 类定义必须保持跨脚本一致：Pickle加载时需要能找到对应的类定义，即序列化时的类名、所在模块路径必须和加载时完全一致，否则会抛出找不到类的异常。
• 不要过度依赖多对象拆分dump：对于有嵌套引用关系的对象树，拆分多次dump/load的写法很难保证对象引用关系的一致性，直接从顶层容器做全量序列化是最稳定、可维护性最高的方案。
• 避免把可变类型定义为类属性：列表、字典这类可变结构如果定义为类层级，所有实例会共享同一份内存地址，很容易出现数据串扰，哪怕不用pickle，在普通业务逻辑里也会出现难以排查的bug。

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