萬盛學電腦網

您现在的位置: 萬盛學電腦網 >> 程式設計 >  >> 網路程式設計 >> 程式語言綜合

Python 序列化與反序列化完整指南:pickle、json、msgpack、protobuf 選型與實戰

序列化核心概念

  • 序列化:對象 → 字節流/字符串(持久化存儲、網絡傳輸、進程間通信)。
  • 反序列化:字節流/字符串 → 對象(還原狀態)。
  • 關鍵指標:支持類型廣度、性能(速度/體積)、跨語言/跨版本兼容性、安全性、人類可讀性。

主流方案對比

1. JSON:通用標準


import json
from dataclasses import dataclass, asdict
from datetime import datetime

@dataclass
class User:
    id: int
    name: str
    email: str
    created_at: datetime
    tags: list[str]

# 自定義編碼器處理 datetime
class EnhancedEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, set):
            return list(obj)
        if hasattr(obj, '__dataclass_fields__'):
            return asdict(obj)
        return super().default(obj)

user = User(1, "Alice", "alice@example.com", datetime.now(), ["vip", "beta"])
json_str = json.dumps(user, cls=EnhancedEncoder, ensure_ascii=False, indent=2)
print(json_str)

# 反序列化需手動轉換
data = json.loads(json_str)
data['created_at'] = datetime.fromisoformat(data['created_at'])
user_restored = User(**data)

2. Pickle:Python 專用深度序列化


import pickle
import _pickle as cPickle  # C 實現,更快

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

p = Person("Bob", 30)

# 协议版本:0(文本), 1(舊二進制), 2(新式二進制), 3/4/5(更高效, Python 3 專用)
# 推薦 protocol=pickle.HIGHEST_PROTOCOL (或 4/5)
data = pickle.dumps(p, protocol=pickle.HIGHEST_PROTOCOL)
p2 = pickle.loads(data)
print(p2)  # Person(Bob, 30)

# 文件操作
with open('person.pkl', 'wb') as f:
    pickle.dump(p, f, protocol=pickle.HIGHEST_PROTOCOL)

with open('person.pkl', 'rb') as f:
    p3 = pickle.load(f)

# ⚠️ 安全警告:絕不可反序列化不可信數據!
# pickle.loads(evil_bytes) 可執行任意代碼 (__reduce__ 魔術方法)

Pickle 進階:自定義序列化邏輯


class Connection:
    def __init__(self, host: str, port: int):
        self.host = host
        self.port = port
        self._socket = None  # 非序列化屬性
    
    def connect(self):
        # 建立連接...
        pass
    
    def __getstate__(self):
        """返回要序列化的狀態字典"""
        return {'host': self.host, 'port': self.port}
    
    def __setstate__(self, state):
        """從狀態字典恢復"""
        self.host = state['host']
        self.port = state['port']
        self._socket = None
        self.connect()  # 反序列化後自動重連

# 測試
import pickle
conn = Connection("localhost", 5432)
data = pickle.dumps(conn)
conn2 = pickle.loads(data)
print(conn2.host, conn2.port)  # localhost 5432

Pickle 自引用處理


# Pickle 智能處理自引用/共享引用
a = [1, 2]
a.append(a)  # 自引用
data = pickle.dumps(a)
b = pickle.loads(data)
print(b[2] is b)  # True,同一對象引用保持

3. MessagePack:高性能二進制 JSON


# pip install msgpack
import msgpack

data = {"users": [{"id": i, "name": f"user{i}"} for i in range(10000)]}

# 序列化
packed = msgpack.packb(data, use_bin_type=True)
print(f"JSON: {len(json.dumps(data))} bytes, MsgPack: {len(packed)} bytes")  # 體積通常減少 30-50%

# 反序列化
unpacked = msgpack.unpackb(packed, raw=False)  # raw=False 返回 str 而非 bytes
print(unpacked['users'][0])

# 自定義類型擴展 (ExtType)
import datetime
def encode_datetime(obj):
    if isinstance(obj, datetime.datetime):
        return msgpack.ExtType(0, obj.isoformat().encode())
    raise TypeError

def decode_datetime(code, data):
    if code == 0:
        return datetime.datetime.fromisoformat(data.decode())
    return msgpack.ExtType(code, data)

packed = msgpack.packb({"time": datetime.datetime.now()}, default=encode_datetime)
unpacked = msgpack.unpackb(packed, ext_hook=decode_datetime, raw=False)

4. Protocol Buffers:契約優先、極致性能


# user.proto
syntax = "proto3";
package example;

message User {
    int64 id = 1;
    string name = 2;
    string email = 3;
    int64 created_at = 4;  // Unix timestamp
    repeated string tags = 5;
}

# 編譯: protoc --python_out=. user.proto
# 生成 user_pb2.py

# 使用
import user_pb2
import time

user = user_pb2.User()
user.id = 1
user.name = "Alice"
user.email = "alice@example.com"
user.created_at = int(time.time())
user.tags.extend(["vip", "beta"])

# 序列化
binary = user.SerializeToString()
print(f"Protobuf size: {len(binary)} bytes")  # 極小

# 反序列化
user2 = user_pb2.User()
user2.ParseFromString(binary)
print(user2.name, user2.tags)

選型決策樹


需要跨語言/跨平台?
├─ 是 → 需要嚴格 Schema、極致性能、gRPC? → Protocol Buffers
│         需要類 JSON 靈活、無 Schema、輕量? → MessagePack
│         需要人類可讀、調試方便、Web API? → JSON
└─ 否 (純 Python 內部)
    ├── 可信環境、需序列化任意對象(含類/函數/閉包)? → Pickle (protocol=4/5)
    ├── 僅基礎類型、追求速度/體積? → MessagePack / orjson (快速 JSON)
    └── 配置文件、日誌、人工可讀? → JSON / YAML / TOML

安全性鐵律

絕不反序列化不可信來源的 Pickle/Marshal/YAML(unsafe_load) 數據。

  • Pickle 通過 `__reduce__` 可執行任意代碼(RCE)。
  • YAML `yaml.load()` (不加 Loader) 同樣危險,必須用 `yaml.safe_load()`。
  • JSON、MsgPack、Protobuf 本身無代碼執行風險(但業務邏輯層仍需驗證數據合法性)。

性能優化清單

  1. **選對工具**:JSON → `orjson`/`ujson`/`simdjson` (C/C++ 加速,比標準庫快 5-10x)。
  2. **預分配/復用緩衝區**:高頻序列化避免重複分配內存。
  3. **避免深層嵌套**:扁平化數據結構利於編碼/解碼。
  4. **批量操作**:一次序列化大列表優於循環序列化單個對象。
  5. **異步序列化**:將序列化移至線程池/進程池,不阻塞事件循環。

總結

序列化無銀彈,按場景選型:

  • Web API/配置/日誌 → **JSON** (`orjson` 加速)
  • Python 微服務內部 RPC/緩存 → **MsgPack** 或 **Pickle (可信環境)**
  • 高性能微服務/gRPC/強契約 → **Protobuf**
  • 科學計算大數組 → **NumPy .npy / Apache Arrow / Parquet**
  • 嵌入式/極簡依賴 → **MsgPack** 或 **Cbor2**

統一封裝 `Serializer` 接口,業務層依賴抽象,底層可熱插拔實現,是架構層面的最佳實踐。

copyright © 萬盛學電腦網 all rights reserved
方案類型支持跨語言速度體積安全性適用場景
json基礎類型(dict/list/str/num/bool/null)✅ 標準中大(文本)✅ 安全API、配置、日誌、跨語言交互
pickle幾乎所有 Python 對象(含自定義類、函數、類)❌ Python 專用中中❌ 不安全(任意代碼執行)Python 進程間通信、緩存、內部存儲(可信數據)
msgpack類 JSON 類型+二進制/擴展類型✅ 多語言快小(二進制)✅ 安全高性能 RPC、緩存、嵌入式、跨語言
protobufSchema 定義結構化數據✅ 多語言極快極小✅ 安全微服務 gRPC、大規模數據存儲、嚴格契約
marshal極窄(內建容器+code object)❌極快小❌.pyc 字節碼、CPython 內部