Python Pickle 模块

在 Python 开发中，我们经常需要把运行时的对象保存下来，或者在程序重启后恢复之前的状态，例如：

• 将计算结果缓存到磁盘，避免重复计算
• 保存用户配置、程序中间状态
• 在不同 Python 进程之间传递复杂对象

pickle 模块正是 Python 为解决这类问题提供的官方内置方案。

Python 的 pickle 模块是一个用于序列化和反序列化 Python 对象的标准库模块。

在开始使用 Pickle 之前，需要理解两个核心概念：

• 序列化（Pickling）：将 Python 对象转换为字节序列
• 反序列化（Unpickling）：将字节序列转换回 Python 对象

pickle 模块可以将几乎所有的 Python 对象（如列表、字典、类实例等）保存到文件中，或者通过网络传输，然后在需要时重新加载。

为什么使用 Pickle 模块？

1. 数据持久化：将 Python 对象保存到文件中，以便在程序关闭后仍然可以访问这些数据。

• 数据传输：通过网络传输 Python 对象，例如在分布式系统中传递数据。
• 快速存储和加载：pickle 模块可以高效地处理复杂的数据结构，适合需要快速存储和加载的场景。

Pickle 的典型使用场景

pickle 非常适合以下场景：

• 本地数据持久化
• 程序运行状态保存与恢复
• 中间计算结果缓存
• Python 进程间通信（IPC）
• 机器学习模型、特征数据的保存

不适合的场景：

• 跨语言数据交换
• 前后端接口数据传输
• 不可信数据源的反序列化

Pickle 支持哪些对象？

1. 支持的对象类型

类型	是否支持
int / float / bool / str	支持
list / tuple / dict / set	支持
None	支持
自定义类实例	支持
嵌套结构	支持

不支持或不推荐的对象

• 打开的文件对象
• socket、数据库连接
• 操作系统资源
• 依赖运行环境状态的对象

导入模块

使用 Pickle 模块非常简单，只需要导入即可：

import pickle

---

Pickle 模块的基本用法

1. 序列化对象

使用 pickle.dump() 方法可以将 Python 对象序列化并保存到文件中。

实例

import pickle

# 创建一个 Python 对象
data = {
    'name': 'Alice',
    'age': 25,
    'hobbies': ['reading', 'traveling']
}

# 将对象序列化并保存到文件
with open('data.pkl', 'wb') as file:
    pickle.dump(data, file)

• 'wb' 表示以二进制写模式打开文件。
• pickle.dump() 将 data 对象序列化并写入文件。

2. 反序列化对象

使用 pickle.load() 方法可以从文件中加载并反序列化 Python 对象。

实例

import pickle

# 从文件中加载并反序列化对象
with open('data.pkl', 'rb') as file:
    loaded_data = pickle.load(file)

print(loaded_data)

• 'rb' 表示以二进制读模式打开文件。
• pickle.load() 从文件中读取字节流并反序列化为 Python 对象。

3.序列化到字节串

如果不想保存到文件，可以使用 pickle.dumps() 将对象序列化为字节串：

实例

import pickle

data = [1, 2, 3, 4, 5]

# 序列化为字节串
byte_data = pickle.dumps(data)
print(byte_data)
# 输出类似: b'\x80\x04\x95\x0f\x00\x00\x00...'


4. 从字节串反序列化

使用 pickle.loads() 可以从字节串反序列化对象：

实例

import pickle

byte_data = b'\x80\x04\x95\x0f\x00\x00\x00\x00\x00\x00\x00]\x94(K\x01K\x02K\x03K\x04K\x05e.'

# 从字节串反序列化
original_data = pickle.loads(byte_data)
print(original_data)
# 输出: [1, 2, 3, 4, 5]


5. 可以序列化的对象类型

Pickle 可以序列化大多数 Python 对象，包括：

• 基本数据类型：整数、浮点数、字符串、布尔值、None
• 集合类型：列表、元组、字典、集合
• 自定义类的实例
• 函数和类（有一定限制）

实例

import pickle

# 序列化不同类型的数据
numbers = [1, 2, 3]
text = "Hello, Pickle"
dictionary = {'key': 'value'}
tuple_data = (1, 2, 3)
set_data = {1, 2, 3}

# 将所有数据放入一个列表
all_data = [numbers, text, dictionary, tuple_data, set_data]

# 序列化
with open('mixed_data.pkl', 'wb') as f:
    pickle.dump(all_data, f)

# 反序列化
with open('mixed_data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)
    print(loaded_data)


6. 序列化自定义类

Pickle 可以很好地处理自定义类的实例：

实例

import pickle

class Student:
    def __init__(self, name, age, grade):
        self.name = name
        self.age = age
        self.grade = grade
   
    def __repr__(self):
        return f"Student(name={self.name}, age={self.age}, grade={self.grade})"

# 创建实例
student = Student("李四", 20, "大三")

# 序列化
with open('student.pkl', 'wb') as f:
    pickle.dump(student, f)

# 反序列化
with open('student.pkl', 'rb') as f:
    loaded_student = pickle.load(f)
    print(loaded_student)
    # 输出: Student(name=李四, age=20, grade=大三)


7. 序列化多个对象

可以多次调用 pickle.dump() 来保存多个对象：

实例

import pickle

data1 = {'item': 'apple', 'count': 5}
data2 = ['banana', 'orange', 'grape']
data3 = 42

# 保存多个对象
with open('multiple.pkl', 'wb') as f:
    pickle.dump(data1, f)
    pickle.dump(data2, f)
    pickle.dump(data3, f)

# 读取多个对象（顺序必须一致）
with open('multiple.pkl', 'rb') as f:
    loaded_data1 = pickle.load(f)
    loaded_data2 = pickle.load(f)
    loaded_data3 = pickle.load(f)
   
print(loaded_data1)
print(loaded_data2)
print(loaded_data3)


8. 实际应用示例

示例1：保存和加载机器学习模型配置

实例

import pickle

# 模拟机器学习模型的配置
model_config = {
    'model_type': 'RandomForest',
    'n_estimators': 100,
    'max_depth': 10,
    'trained_date': '2024-01-13',
    'accuracy': 0.95
}

# 保存配置
with open('model_config.pkl', 'wb') as f:
    pickle.dump(model_config, f)

# 加载配置
with open('model_config.pkl', 'rb') as f:
    config = pickle.load(f)
    print(f"模型类型: {config['model_type']}")
    print(f"准确率: {config['accuracy']}")


示例2：缓存计算结果

实例

import pickle
import os

def expensive_computation(n):
    """模拟耗时的计算"""
    result = sum(i ** 2 for i in range(n))
    return result

def compute_with_cache(n, cache_file='cache.pkl'):
    # 检查缓存是否存在
    if os.path.exists(cache_file):
        with open(cache_file, 'rb') as f:
            cache = pickle.load(f)
            if n in cache:
                print("从缓存中读取结果")
                return cache[n]
    else:
        cache = {}
   
    # 执行计算
    print("执行计算...")
    result = expensive_computation(n)
   
    # 保存到缓存
    cache[n] = result
    with open(cache_file, 'wb') as f:
        pickle.dump(cache, f)
   
    return result

# 使用示例
print(compute_with_cache(1000000))  # 第一次会计算
print(compute_with_cache(1000000))  # 第二次从缓存读取


---

Pickle 模块的注意事项

1. 安全性：pickle 模块在反序列化时会执行任意代码，因此不要加载来自不可信来源的 pickle 数据，以免遭受恶意攻击。

• 兼容性：pickle 生成的字节流是 Python 特有的，不同版本的 Python 之间可能存在兼容性问题。
• 性能：对于大型数据集，pickle 的序列化和反序列化可能会比较慢，可以考虑使用更高效的序列化工具，如 json 或 msgpack。

高级用法：自定义对象的序列化

pickle 模块支持自定义类的序列化。默认情况下，pickle 会保存对象的属性和类名。如果需要更复杂的序列化逻辑，可以在类中实现 __getstate__() 和 __setstate__() 方法。

pickle 模块常用方法

1. 序列化对象到文件

2. 从文件反序列化

3. 序列化为字节串（网络传输/缓存）

pickle 模块协议版本