Python Pickle 模块
在 Python 开发中，我们经常需要把运行时的对象保存下来，或者在程序重启后恢复之前的状态，例如：
- 将计算结果缓存到磁盘，避免重复计算
- 保存用户配置、程序中间状态
- 在不同 Python 进程之间传递复杂对象
pickle 模块正是 Python 为解决这类问题提供的官方内置方案。
Python 的 pickle 模块是一个用于序列化和反序列化 Python 对象的标准库模块。
在开始使用 Pickle 之前，需要理解两个核心概念：
- 序列化（Pickling）：将 Python 对象转换为字节序列
- 反序列化（Unpickling）：将字节序列转换回 Python 对象
pickle 模块可以将几乎所有的 Python 对象（如列表、字典、类实例等）保存到文件中，或者通过网络传输，然后在需要时重新加载。
为什么使用 Pickle 模块？
- 数据持久化：将 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)
# 创建一个 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)
# 从文件中加载并反序列化对象
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...'
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]
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)
# 序列化不同类型的数据
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=大三)
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)
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']}")
# 模拟机器学习模型的配置
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)) # 第二次从缓存读取
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 模块的注意事项
- 安全性：
pickle模块在反序列化时会执行任意代码，因此不要加载来自不可信来源的pickle数据，以免遭受恶意攻击。 - 兼容性：
pickle生成的字节流是 Python 特有的，不同版本的 Python 之间可能存在兼容性问题。 - 性能：对于大型数据集，
pickle的序列化和反序列化可能会比较慢，可以考虑使用更高效的序列化工具，如json或msgpack。
高级用法：自定义对象的序列化
pickle 模块支持自定义类的序列化。默认情况下，pickle 会保存对象的属性和类名。如果需要更复杂的序列化逻辑，可以在类中实现 __getstate__() 和 __setstate__() 方法。
实例
import pickle
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __getstate__(self):
# 自定义序列化逻辑
return {'name': self.name, 'age': self.age}
def __setstate__(self, state):
# 自定义反序列化逻辑
self.name = state['name']
self.age = state['age']
# 创建对象并序列化
person = Person('Bob', 30)
with open('person.pkl', 'wb') as file:
pickle.dump(person, file)
# 反序列化对象
with open('person.pkl', 'rb') as file:
loaded_person = pickle.load(file)
print(loaded_person.name, loaded_person.age)
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __getstate__(self):
# 自定义序列化逻辑
return {'name': self.name, 'age': self.age}
def __setstate__(self, state):
# 自定义反序列化逻辑
self.name = state['name']
self.age = state['age']
# 创建对象并序列化
person = Person('Bob', 30)
with open('person.pkl', 'wb') as file:
pickle.dump(person, file)
# 反序列化对象
with open('person.pkl', 'rb') as file:
loaded_person = pickle.load(file)
print(loaded_person.name, loaded_person.age)
pickle 模块常用方法
| 方法 | 说明 | 示例 |
|---|---|---|
pickle.dump(obj, file) | 将对象序列化并写入文件 | pickle.dump(data, open('data.pkl', 'wb')) |
pickle.load(file) | 从文件读取并反序列化对象 | data = pickle.load(open('data.pkl', 'rb')) |
pickle.dumps(obj) | 将对象序列化为字节串 | bytes_data = pickle.dumps([1, 2, 3]) |
pickle.loads(bytes) | 从字节串反序列化对象 | lst = pickle.loads(bytes_data) |
pickle.HIGHEST_PROTOCOL | 可用的最高协议版本（属性） | pickle.dump(..., protocol=pickle.HIGHEST_PROTOCOL) |
pickle.DEFAULT_PROTOCOL | 默认协议版本（属性，通常为4） | pickle.dumps(obj, protocol=pickle.DEFAULT_PROTOCOL) |
1. 序列化对象到文件
实例
import pickle
data = {'name': 'Alice', 'age': 25}
with open('data.pkl', 'wb') as f:
pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
data = {'name': 'Alice', 'age': 25}
with open('data.pkl', 'wb') as f:
pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
2. 从文件反序列化
实例
with open('data.pkl', 'rb') as f:
loaded_data = pickle.load(f)
print(loaded_data) # 输出: {'name': 'Alice', 'age': 25}
loaded_data = pickle.load(f)
print(loaded_data) # 输出: {'name': 'Alice', 'age': 25}
3. 序列化为字节串（网络传输/缓存）
实例
bytes_data = pickle.dumps([1, 2, 3], protocol=4)
restored_list = pickle.loads(bytes_data)
restored_list = pickle.loads(bytes_data)
pickle 模块协议版本
| 协议版本 | 说明 |
|---|---|
| 0 | 人类可读的ASCII格式（兼容旧版） |
| 1 | 二进制格式（兼容旧版） |
| 2 | Python 2.3+ 优化支持类对象 |
| 3 | Python 3.0+ 默认协议（不支持Python 2） |
| 4 | Python 3.4+ 支持更大对象和更多数据类型 |
| 5 | Python 3.8+ 支持内存优化和数据共享 |
点我分享笔记