在 Python 编程的世界里，序列化是一个绕不开的关键话题，它就像数据的 “魔法变身器”，能够将内存中复杂的数据结构和对象，转化为可以存储在磁盘上，或者在网络中传输的格式，比如字节流或者字符串。当我们需要保存程序的运行状态，下次启动时能快速恢复，又或者需要将数据发送给其他程序、其他服务器时，序列化就派上用场了。反序列化则是这个过程的逆操作，把存储或传输的数据重新变回程序中可以直接使用的对象。

二、pickle 模块详解

2.1 pickle 模块概述

2.2 核心函数

import pickle
data = {'name': 'Alice', 'age': 25, 'hobbies': ['reading','swimming']}
with open('data.pkl', 'wb') as file:
    pickle.dump(data, file)

import pickle
data = [1, 2, 3, 4, 5]
serialized_data = pickle.dumps(data)
print(serialized_data)

import pickle
with open('data.pkl', 'rb') as file:
    loaded_data = pickle.load(file)
print(loaded_data)

import pickle
serialized_data = b'\x80\x04\x95\x16\x00\x00\x00\x00\x00\x00\x00]\x94(K\x01K\x02K\x03K\x04K\x05e.'
loaded_data = pickle.loads(serialized_data)
print(loaded_data)

2.3 应用场景与案例

import pickle
class GameSave:
    def __init__(self, player_name, level, score):
        self.player_name = player_name
        self.level = level
        self.score = score
# 创建游戏存档实例
save = GameSave('Player1', 5, 300)
# 序列化并保存到文件
with open('game_save.pkl', 'wb') as file:
    pickle.dump(save, file)

import pickle
class GameSave:
    def __init__(self, player_name, level, score):
        self.player_name = player_name
        self.level = level
        self.score = score
# 从文件中读取并反序列化
with open('game_save.pkl', 'rb') as file:
    loaded_save = pickle.load(file)
print(f"玩家: {loaded_save.player_name}，等级: {loaded_save.level}，分数: {loaded_save.score}")

import pickle
import time
def compute_statistics():
    # 模拟复杂的数据计算，这里用sleep代替
    time.sleep(5)
    return {'mean': 10.5,'std': 2.3, 'count': 100}
try:
    with open('statistics.pkl', 'rb') as file:
        stats = pickle.load(file)
    print("从缓存中读取统计信息")
except FileNotFoundError:
    stats = compute_statistics()
    with open('statistics.pkl', 'wb') as file:
        pickle.dump(stats, file)
    print("计算并保存统计信息")
print(stats)

2.4 潜在风险

三、json 模块详解

3.1 json 模块概述

3.2 核心函数

import json
data = {'name': '张三', 'age': 20, 'hobbies': ['篮球', '阅读']}
with open('info.json', 'w', encoding='utf-8') as file:
    json.dump(data, file, ensure_ascii=False, indent=4)

import json
data = [1, 2, 3, 'a', True]
serialized_data = json.dumps(data)
print(serialized_data)

import json
with open('info.json', 'r', encoding='utf-8') as file:
    loaded_data = json.load(file)
print(loaded_data)

import json
json_str = '{"name": "李四", "age": 25, "is_student": false}'
loaded_data = json.loads(json_str)
print(loaded_data)

3.3 应用场景与案例

from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/user/<int:user_id>', methods=['GET'])
def get_user(user_id):
    user = {'id': user_id, 'name': '王五', 'email': 'wangwu@example.com'}
    return jsonify(user)
if __name__ == '__main__':
    app.run(debug=True)

{
  "host": "127.0.0.1",
  "port": 3306,
  "username": "root",
  "password": "password",
  "database": "test_db"
}

import json
with open('config.json', 'r') as file:
    config = json.load(file)
print(config)

3.4 自定义编解码

import json
class Book:
    def __init__(self, title, author, publication_year):
        self.title = title
        self.author = author
        self.publication_year = publication_year
# 自定义编码器
class BookEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, Book):
            return {
                'title': obj.title,
                'author': obj.author,
                'publication_year': obj.publication_year
            }
        return super().default(obj)
# 自定义解码器
class BookDecoder(json.JSONDecoder):
    def __init__(self, *args, **kwargs):
        super().__init__(object_hook=self.book_decoder, *args, **kwargs)
    def book_decoder(self, dct):
        if 'title' in dct and 'author' in dct and 'publication_year' in dct:
            return Book(dct['title'], dct['author'], dct['publication_year'])
        return dct
book = Book('Python基础教程', '张三', 2022)
# 使用自定义编码器进行编码
json_str = json.dumps(book, cls=BookEncoder)
print(json_str)
# 使用自定义解码器进行解码
loaded_book = json.loads(json_str, cls=BookDecoder)
print(loaded_book.title)

四、pickle 与 json 对比分析

4.1 安全性

4.2 可读性

import pickle
data = {'key': 'value'}
serialized = pickle.dumps(data)
print(serialized)
# 输出类似 b'\x80\x04\x95\x13\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x03key\x94\x8c\x05value\x94u.'

import json
data = {'key': 'value'}
serialized = json.dumps(data)
print(serialized)
# 输出 {"key": "value"}

4.3 兼容性

4.4 可序列化类型

import pickle
def my_function():
    print("这是一个函数")
class MyClass:
    def __init__(self):
        self.value = 42
obj = MyClass()
serialized_function = pickle.dumps(my_function)
serialized_obj = pickle.dumps(obj)

import json
class MyClass:
    def __init__(self):
        self.value = 42
obj = MyClass()
try:
    json.dumps(obj)
except TypeError as e:
    print(f"错误: {e}")
# 输出 错误: Object of type MyClass is not JSON serializable

4.5 性能比较

import json
import pickle
import timeit
data = list(range(10000))
pickle_time = timeit.timeit(lambda: pickle.dumps(data), number=1000)
json_time = timeit.timeit(lambda: json.dumps(data), number=1000)
print(f"pickle序列化1000次耗时: {pickle_time} 秒")
print(f"json序列化1000次耗时: {json_time} 秒")