Python3 Pickle 模块基本用法详解

import pickle
# 定义一个复杂对象（包含多种类型）
data = {
    "name": "Alice",
    "age": 30,
    "hobbies": ["reading", "hiking"],
    "is_student": False,
    "scores": (90.5, 85.0)
}
# 方法1：用dumps()序列化为字节流
data_bytes = pickle.dumps(data)
print("序列化结果（字节流）：", data_bytes)  # 输出b'\x80\x04...'（二进制数据）
# 方法2：用dump()序列化到文件
with open("data.pkl", "wb") as f:  # 必须用二进制模式"wb"
    pickle.dump(data, f)

import pickle
# 方法1：用loads()从字节流反序列化
data_bytes = pickle.dumps({"name": "Alice"})
restored_data = pickle.loads(data_bytes)
print("从字节流恢复：", restored_data)  # 输出 {'name': 'Alice'}
# 方法2：用load()从文件反序列化
with open("data.pkl", "rb") as f:  # 必须用二进制模式"rb"
    restored_from_file = pickle.load(f)
print("从文件恢复：", restored_from_file)  # 输出原始data字典

import pickle
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greet(self):
        return f"Hello, I'm {self.name}!"
# 创建实例
person = Person("Bob", 25)
# 序列化
person_bytes = pickle.dumps(person)
# 反序列化（需确保Person类在当前作用域中）
restored_person = pickle.loads(person_bytes)
print(restored_person.greet())  # 输出 "Hello, I'm Bob!"
print(restored_person.age)      # 输出 25

import pickle
class User:
    def __init__(self, username, password):
        self.username = username
        self.password = password  # 敏感信息，不希望被序列化
    # 自定义序列化内容：只保留username
    def __getstate__(self):
        return {"username": self.username}
    # 自定义反序列化逻辑：恢复状态
    def __setstate__(self, state):
        self.username = state["username"]
        self.password = "default"  # 反序列化时密码设为默认值
# 创建实例
user = User("alice123", "secret123")
# 序列化
user_bytes = pickle.dumps(user)
# 反序列化
restored_user = pickle.loads(user_bytes)
print(restored_user.username)  # 输出 "alice123"
print(restored_user.password)  # 输出 "default"（敏感信息未被序列化）

import pickle
data = [i for i in range(1000)]
# 使用协议4序列化（效率更高）
data_bytes = pickle.dumps(data, protocol=4)

import pickle
import time
def expensive_computation():
    # 模拟耗时计算
    time.sleep(3)
    return [i**2 for i in range(1000)]
# 检查是否有缓存
try:
    with open("result_cache.pkl", "rb") as f:
        result = pickle.load(f)
        print("从缓存加载结果")
except FileNotFoundError:
    # 无缓存则计算并保存
    result = expensive_computation()
    with open("result_cache.pkl", "wb") as f:
        pickle.dump(result, f)
    print("计算完成并缓存")

from multiprocessing import Process
import pickle
def process_data(data):
    print("子进程接收数据：", data)
if __name__ == "__main__":
    # 定义复杂对象
    data = {"task": "process", "params": [1, 2, 3]}
    # 多进程会自动序列化data并传递给子进程
    p = Process(target=process_data, args=(data,))
    p.start()
    p.join()