Python 3.15 pickle 这个改进救了多少新手?再也不用为私有方法打包发愁了

# Python 3.14 自定义类里有 __私有方法__ 还能 pickle

# 但如果是单纯的 _下划线开头 的私有方法 + 嵌套类，3.14 直接报错

class User:

    class Profile:    # 嵌套类

        def __init__(self, name):

            self.name = name

    def _get_profile(self):  # 私有方法

        return self.Profile("小明")

import pickle

u = User()

pickle.dumps(u)  # Python 3.14: 报错 PicklingError

# 报错信息（3.14）:

# _pickle.PicklingError: Can't pickle <class 'User.Profile'>:

#   attribute lookup User.Profile on __main__ failed

# Python 3.15 同样的代码

import pickle

u = User()

data = pickle.dumps(u)   # 正常序列化

u2 = pickle.loads(data)  # 反序列化回来

print(u2._get_profile().name)  # 小明

# 私有方法也能直接 pickle

class Config:

    def _private_helper(self, x):

        return x * 2

    def save(self, path):

        with open(path, "wb") as f:

            pickle.dump(self, f)  # 3.15 不再报错

# 实战1：保存嵌套数据类的用户配置

import pickle

class AppConfig:

    class Database:

        def __init__(self):

            self.host = "localhost"

            self.port = 3306

    class Cache:

        def __init__(self):

            self.ttl = 300

    def __init__(self):

        self.db = self.Database()

        self.cache = self.Cache()

config = AppConfig()

# 3.14 报错，3.15 顺利保存

pickle.dump(config, open("config.pkl", "wb"))

# 下次启动直接加载

cfg = pickle.load(open("config.pkl", "rb"))

print(cfg.db.host)  # localhost

# 实战2：Django 风格的模型 + 私有序列化方法

import pickle

class Article:

    def __init__(self, title, content):

        self.title = title

        self.content = content

        self._views = 0

    def _increase_views(self):  # 私有方法

        self._views += 1

articles = [Article("Python 3.15 来了", "..."),

            Article("pickle 升级", "...")]

# 3.15 之前 _increase_views 是私有的会报 PicklingError

# 3.15 直接 dump 成功

data = pickle.dumps(articles)

restored = pickle.loads(data)

restored[0]._increase_views()

print(restored[0]._views)  # 1

# 实战3：multiprocessing 任务队列

import pickle

from multiprocessing import Pool

class Task:

    class Result:

        def __init__(self, code, msg):

            self.code = code

            self.msg = msg

    def _execute(self):  # 私有执行方法

        return self.Result(200, "ok")

def run(task):

    return task._execute()

# 多进程必须能 pickle 才能传到子进程

# 3.15 之前 Task 嵌套类 + 私有方法会失败

with Pool(2) as p:

    results = p.map(run, [Task() for _ in range(4)])

    for r in results:

        print(r.code, r.msg)  # 200 ok

# 坑1：__init__ 等双下划线方法（dunder）依然不能 pickle

class A:

    def __init__(self):

        self.x = 1

class B:

    def __init__(self):

        pass

    def __deepcopy__(self, memo):  # dunder 不能 pickle

        return B()

# 这两种方法不算"私有方法"，是魔术方法

# pickle 通过 __reduce__ 处理它们，依然受老规则限制

# 坑2：函数内部动态定义的类（locals()）依然不能 pickle

def factory():

    class Local:

        pass

    return Local

Cls = factory()

obj = Cls()

# pickle.dumps(obj)  # 还是报 PicklingError

# 3.15 只解决了"在模块级、类里、嵌套类里"的私有方法和嵌套类

# 动态生成的依然不行

# 坑3：3.15 序列化的文件，3.14 读不了

# pickle 协议有兼容性，但私有方法查找逻辑变了

# 如果你的 pickle 文件要在多版本 Python 间共享

# 建议用 protocol=5 并测试两端

data = pickle.dumps(obj, protocol=5)

# 推荐做法：生产环境统一升级到 3.15 再启用这个特性

# 别一上来就在 3.14 序列化的文件上加嵌套类

# 验证：3.14 vs 3.15 报错对比

class Outer:

    class Inner:

        def hello(self):

            return "hi"

    def _helper(self):

        return self.Inner()

import pickle, sys

print("Python:", sys.version_info[:2])  # 看看你跑的是哪个版本

o = Outer()

try:

    blob = pickle.dumps(o)

    print("OK")  # 3.15 输出 OK

except Exception as e:

    print("FAIL:", e)  # 3.14 输出 FAIL: PicklingError...