动动小手，点击关注，感谢您的阅读，您的关注是我最大的动力！！！！

在 Python 编程中，数据持久化是将程序运行时的对象保存到磁盘，以便后续恢复使用的关键技术。pickle模块作为Python的内置工具，能轻松实现对象的序列化与反序列化。本文将通过核心函数、实战案例和避坑指南，带你掌握这一高效的数据处理利器！

一、Pickle是什么？

pickle是Python的标准库，用于将Python对象（如列表、字典、类实例）转换为字节流（序列化），并在需要时重新转换回对象（反序列化）。

• 简单易用：无需复杂配置，几行代码即可完成对象存储与读取。
• 保留对象类型：反序列化后恢复原始对象的类型和属性。

二 、pickle与json是什么区别？

• pickle定位：Python专属的二进制序列化协议，仅适用于 Python 环境，序列化后的数据无法被其他语言解析。
• JSON定位：跨语言的文本格式（基于JavaScript对象表示法），用于数据交换（如 API 接口、配置文件等）。并且json数据存储的是人类可读的文本字符串，必须处理字符集编码，否则可能出现乱码。

三、核心函数与案例

1.pickle.dump()：序列化对象并保存到文件

语法：pickle.dump(obj, file)

• obj：要序列化的 Python 对象（如列表、字典）。
• file：文件对象（需以二进制写入模式 'wb' 打开）。

案例：保存字典到文件

import pickle

# 待保存的字典
data = {
    "name": "Alice",
    "age": 30,
    "hobbies": ["reading", "swimming"]
}

# 将数据保存到文件
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f)

print("数据已保存到 data.pkl")

2.pickle.load()：从文件中读取并反序列化对象

语法：pickle.load(file)

• file：文件对象（需以二进制读取模式 'rb' 打开）。
• 返回值：恢复后的原始 Python 对象。

案例：读取上例保存的字典

import pickle

# 从文件中读取数据
with open('data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)

print(loaded_data)
# 输出: {'name': 'Alice', 'age': 30, 'hobbies': ['reading','swimming']}

3.pickle.dumps()：将对象序列化为字节串

语法：pickle.dumps(obj)

• 返回值：对象对应的字节串，可用于网络传输或内存存储。

案例：将列表转换为字节串

import pickle

my_list = [1, 2, 3, 4]
byte_string = pickle.dumps(my_list)
print(byte_string)
# 输出: b'\x80\x04\x95\x10\x00\x00\x00\x00\x00\x00\x00]\x94(K\x01K\x02K\x03K\x04e.'

4.pickle.loads()：从字节串反序列化为对象

语法：pickle.loads(byte_string)

• byte_string：通过pickle.dumps()生成的字节串。

案例：恢复字节串为列表

import pickle

byte_string = b'\x80\x04\x95\r\x00\x00\x00\x00\x00\x00\x00]\x94(K\x01K\x02K\x03K\x04e.'
original_list = pickle.loads(byte_string)
print(original_list)
# 输出: [1, 2, 3, 4]

案例 1：保存自定义类实例

import pickle

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 创建实例
person = Person("Bob", 25)

# 保存实例到文件
with open('person.pkl', 'wb') as f:
    pickle.dump(person, f)

# 读取实例
with open('person.pkl', 'rb') as f:
    loaded_person = pickle.load(f)
print(loaded_person.name, loaded_person.age)
# 输出: Bob 25

案例 2：批量处理数据

import pickle

# 多个数据对象
data_list = [
    {"id": 1, "value": "A"},
    {"id": 2, "value": "B"},
    {"id": 3, "value": "C"}
]

# 批量保存
with open('batch_data.pkl', 'wb') as f:
    for data in data_list:
        pickle.dump(data, f)

# 批量读取
with open('batch_data.pkl', 'rb') as f:
    while True:
        try:
            loaded_data = pickle.load(f)
            print(loaded_data)
        except EOFError:
            break

在掌握了Pickle 的基础序列化功能后，其实它还有许多高级用法和隐藏技巧，能应对更复杂的场景。

四、协议版本控制：兼顾兼容性与性能

Pickle 支持多种协议版本，不同版本在兼容性和性能上有所差异。

1. 协议版本说明

2. 指定协议版本

import pickle

data = {"大型数据": [1, 2, 3] * 10000}

# 使用最高效的协议（当前Python版本支持的最新协议）
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)

# 或指定特定协议（如协议4，兼容Python 3.4+）
with open('data_v4.pkl', 'wb') as f:
    pickle.dump(data, f, protocol=4)

闭坑指南：

• 若需兼容旧版 Python（如 2.x），建议使用协议 2：protocol=2。
• 处理大型二进制数据（如 NumPy 数组）时，优先使用协议 5（Python 3.8+）。

五、自定义序列化行为：控制对象如何被 Pickle

通过在类中定义特殊方法，可以自定义对象的序列化逻辑，实现更灵活的控制。

1.__getstate__和__setstate__方法

• __getstate__()：定义对象被序列化时要保存的状态。
• __setstate__(state)：定义对象被反序列化时如何恢复状态。

案例：自定义序列化一个包含文件句柄的类

import pickle

class FileHandler:
    def __init__(self, filename):
        self.filename = filename
        self.file = open(filename, 'r')  # 文件句柄不能直接序列化
    
    def __getstate__(self):
        # 只保存文件名，不保存文件句柄
        state = self.__dict__.copy()
        state['file'] = None  # 移除不可序列化的属性
        return state
    
    def __setstate__(self, state):
        # 恢复状态时重新打开文件
        self.__dict__.update(state)
        if self.filename:
            self.file = open(self.filename, 'r')

# 使用示例
fh = FileHandler('test.txt')
with open('fh.pkl', 'wb') as f:
    pickle.dump(fh, f)  # 安全序列化，跳过文件句柄

with open('fh.pkl', 'rb') as f:
    loaded_fh = pickle.load(f)  # 自动恢复文件句柄

2.__reduce__方法：更底层的控制

用于完全自定义对象的序列化方式，适用于复杂对象（如C扩展类型）。

案例：自定义序列化一个数据库连接

import pickle
import sqlite3

class DatabaseConnection:
    def __init__(self, db_path):
        self.db_path = db_path
        self.connection = sqlite3.connect(db_path)
    
    def __reduce__(self):
        # 返回一个元组：(重建函数, 函数参数)
        return (DatabaseConnection, (self.db_path,))

# 使用示例
db = DatabaseConnection('example.db')
with open('db.pkl', 'wb') as f:
    pickle.dump(db, f)  # 序列化时仅保存数据库路径

with open('db.pkl', 'rb') as f:
    loaded_db = pickle.load(f)  # 反序列化时重新创建连接

六、内存优化：使用Pickler和Unpickler类

对于大型数据或需要精细控制的场景，可以使用pickle的Pickler和Unpickler类。

1. 分块处理大型数据

避免一次性加载整个文件到内存，适用于 GB 级数据：

import pickle

# 分块保存大型列表
data = [1, 2, 3] * 1000000

with open('large_data.pkl', 'wb') as f:
    pickler = pickle.Pickler(f)
    for chunk in [data[i:i+1000] for i in range(0, len(data), 1000)]:
        pickler.dump(chunk)

# 分块读取
with open('large_data.pkl', 'rb') as f:
    unpickler = pickle.Unpickler(f)
    while True:
        try:
            chunk = unpickler.load()
            process_chunk(chunk)  # 处理每一块数据
        except EOFError:
            break

2. 自定义反序列化行为

通过继承Unpickler类，可以拦截并修改反序列化过程：

import pickle

class CustomUnpickler(pickle.Unpickler):
    def find_class(self, module, name):
        # 自定义类查找逻辑，可用于处理类重命名或移动
        if module == 'old_module' and name == 'OldClass':
            from new_module import NewClass
            return NewClass
        return super().find_class(module, name)

# 使用自定义Unpickler
with open('old_data.pkl', 'rb') as f:
    data = CustomUnpickler(f).load()

七、安全增强：限制可反序列化的类

为防止恶意代码执行，可以限制 pickle 允许反序列化的类：

1. 使用Unpickler.find_class方法

import pickle

class RestrictedUnpickler(pickle.Unpickler):
    # 允许反序列化的类白名单
    ALLOWED_CLASSES = {'__builtin__.list', '__builtin__.dict', '__builtin__.str'}
    
    def find_class(self, module, name):
        class_name = f'{module}.{name}'
        if class_name not in self.ALLOWED_CLASSES:
            raise pickle.UnpicklingError(f"不允许反序列化类: {class_name}")
        return super().find_class(module, name)

# 使用安全的Unpickler
with open('safe_data.pkl', 'rb') as f:
    data = RestrictedUnpickler(f).load()  # 只允许白名单中的类

2. 替代方案：使用dill库

dill是pickle 的增强版本，支持更多类型（如函数、类）的序列化，并提供更安全的选项。

安装dill：pip install dill

import dill

# 安全模式：禁用危险类的序列化
dill.settings['recurse'] = True  # 递归序列化复杂对象
dill.dump(func, open('func.pkl', 'wb'), safe=True)  # 安全模式

八、总结

pickle是 Python 数据持久化的 “瑞士军刀”，适用于快速保存和恢复对象状态。但使用时需牢记安全第一，避免在不可信环境中反序列化数据。结合其他数据存储方案（如 JSON、SQL），能进一步提升项目的灵活性与可靠性！