Python3 pickle模塊的實現(xiàn)步驟

更新時間：2026年03月16日 08:46:00 作者：Frunze軟件開發(fā)

Python的pickle模塊提供強大的對象序列化功能,本文就來詳細的介紹一下Python3 pickle模塊的實現(xiàn)步驟,文中通過示例代碼介紹的非常詳細,需要的朋友們下面隨著小編來一起學習學習吧

1. 基本用法

1.1 序列化對象（pickling）

import pickle

data = {
    'name': 'Alice',
    'age': 30,
    'scores': [85, 92, 88],
    'is_active': True
}

# 序列化到字節(jié)對象
serialized = pickle.dumps(data)
print(serialized)  # 輸出字節(jié)序列

# 序列化到文件
with open('data.pkl', 'wb') as f:  # 注意是二進制寫入模式
    pickle.dump(data, f)

1.2 反序列化對象（unpickling）

import pickle

# 首先創(chuàng)建一個示例數(shù)據(jù)對象
data = {
    'name': 'Alice',
    'age': 30,
    'scores': [85, 92, 88],
    'is_active': True
}

# 1. 序列化對象到字節(jié)（創(chuàng)建serialized變量）
serialized = pickle.dumps(data)
print("序列化后的字節(jié)數(shù)據(jù):", serialized)

# 2. 從字節(jié)對象反序列化
deserialized = pickle.loads(serialized)
print("反序列化后的數(shù)據(jù):", deserialized)  # 輸出原始數(shù)據(jù)

# 3. 序列化到文件
with open('data.pkl', 'wb') as f:  # 注意是二進制寫入模式
    pickle.dump(data, f)

# 4. 從文件反序列化
with open('data.pkl', 'rb') as f:  # 注意是二進制讀取模式
    loaded_data = pickle.load(f)
    print("從文件加載的數(shù)據(jù):", loaded_data)

2. 可序列化的對象類型

pickle 可以序列化大多數(shù) Python 對象，包括：

基本數(shù)據(jù)類型（int, float, bool, str 等）
容器類型（list, tuple, dict, set）
函數(shù)和類（只序列化名稱，不序列化代碼）
類的實例（包括自定義類）
模塊級函數(shù)和類

3. 高級特性

3.1 自定義類的序列化

import pickle

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

alice = Person('Alice', 30)

# 序列化自定義類實例
with open('person.pkl', 'wb') as f:
    pickle.dump(alice, f)

# 反序列化
with open('person.pkl', 'rb') as f:
    loaded_person = pickle.load(f)
    print(loaded_person)  # Person(name='Alice', age=30)

3.2 序列化協(xié)議版本

pickle 有多個協(xié)議版本，可以通過 protocol 參數(shù)指定：

# 使用最高效的協(xié)議版本（Python 3.8+默認使用協(xié)議4）
pickle.dumps(data, protocol=pickle.HIGHEST_PROTOCOL)

# 可用的協(xié)議版本：
# 0 - 原始ASCII協(xié)議（兼容舊版本）
# 1 - 舊二進制格式
# 2 - Python 2.3引入
# 3 - Python 3.0引入（默認Python 3.0-3.7）
# 4 - Python 3.4引入（默認Python 3.8+）
# 5 - Python 3.8引入（支持帶外數(shù)據(jù)）

4. 安全注意事項

?? 重要警告：pickle 反序列化可以執(zhí)行任意代碼，永遠不要反序列化不受信任來源的數(shù)據(jù)！

# 不安全的做法（可能執(zhí)行惡意代碼）
malicious_data = b"cos\nsystem\n(S'rm -rf /'\ntR."  # 模擬惡意pickle數(shù)據(jù)
# pickle.loads(malicious_data)  # 危險！會執(zhí)行系統(tǒng)命令

安全替代方案：

對于不受信任的數(shù)據(jù)，使用 json 模塊
或者使用 ast.literal_eval() 處理簡單數(shù)據(jù)結構

5. 特殊方法控制序列化

自定義類可以通過實現(xiàn)特殊方法來控制序列化行為：

import pickle

class CustomObject:
    def __init__(self, value):
        self.value = value
        self._internal = "secret"
    
    # 定義序列化時要保存的屬性
    def __getstate__(self):
        state = self.__dict__.copy()
        del state['_internal']  # 不序列化內部屬性
        return state
    
    # 定義反序列化時的行為
    def __setstate__(self, state):
        self.__dict__.update(state)
        self._internal = "restored"  # 恢復時重新設置

obj = CustomObject(42)
serialized = pickle.dumps(obj)
new_obj = pickle.loads(serialized)
print(new_obj.value)  # 42
print(new_obj._internal)  # "restored"

6. 性能優(yōu)化

對于大型對象的序列化：

# 使用更高效的協(xié)議
data = [i**2 for i in range(100000)]

# 比較不同協(xié)議的大小
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
    size = len(pickle.dumps(data, protocol=proto))
    print(f"協(xié)議 {proto}: {size} 字節(jié)")

# 使用更快的pickle實現(xiàn)（需要安裝）
# pip install pickle5  # 對于Python < 3.8想使用協(xié)議5

7. 實際應用場景

7.1 緩存計算結果

import pickle
import hashlib
import os

def compute_expensive_operation(params):
    cache_file = f"cache_{hashlib.md5(str(params).encode()).hexdigest()}.pkl"
    
    if os.path.exists(cache_file):
        with open(cache_file, 'rb') as f:
            return pickle.load(f)
    
    # 模擬耗時計算
    result = sum(x**2 for x in range(params['n']))
    
    # 緩存結果
    with open(cache_file, 'wb') as f:
        pickle.dump(result, f)
    
    return result

7.2 進程間通信

import pickle
from multiprocessing import Pool

# 在多進程中使用pickle傳遞數(shù)據(jù)

def process_data(data):
    # 處理數(shù)據(jù)...
    return data * 2

if __name__ == '__main__':
    data = [1, 2, 3, 4, 5]
    with Pool() as pool:
        results = pool.map(process_data, data)
    print(results)  # [2, 4, 6, 8, 10]