Python JSON 库深度对比：json、simdjson 与 orjson

正在生成测试数据... 生成完成，JSON 大小：6.25 MB 正在测试标准 json 库（仅解析）... 正在测试 simdjson（仅解析）... 正在测试 orjson（仅解析）... 📊 纯解析性能对比结果：标准 json 平均时间：0.124597 秒 simdjson 平均时间：0.013677 秒 orjson 平均时间：0.088928 秒 simdjson 加速比：9.11x orjson 加速比：1.40x 

✅ 结论：在纯解析场景，simdjson 确实遥遥领先。

📌 场景 B：完整 ETL 流程（解析 + 修改 + 序列化）

import json
import time
import orjson
import simdjson
import random
import string

def generate_large_json(num_records: int = 50000) -> str:
    def random_string(length=10):
        return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
    data = []
    for i in range(num_records):
        record = {
            "id": i,
            "name": random_string(8),
            "email": f"{random_string(5)}@example.com",
            "score": round(random.uniform(0, 100), 2),
            "tags": [random_string(4) for _ in range(random.randint(1, 5))],
            "active": random.choice([True, False])
        }
        data.append(record)
    return json.dumps(data, ensure_ascii=False)

def benchmark_etl():
    print("正在生成测试数据...")
    json_str = generate_large_json(num_records=50000)
    print(f"生成完成，JSON 大小：{len(json_str)/(1024*1024):.2f} MB")
    # Warm-up
    small_json = '{"test": true}'
    _ = json.loads(small_json)
    _ = orjson.loads(small_json)
    _ = simdjson.Parser().parse(small_json)

    # --- 标准 json：解析 → 修改 → 序列化 ---
    print("正在测试标准 json 库（完整流程）...")
    start = time.perf_counter()
    for _ in range(5):
        data = json.loads(json_str)
        for item in data:
            item["grade"] = "A" if item["score"] >= 90 else "B"
        new_json = json.dumps(data, ensure_ascii=False)
    std_time = (time.perf_counter() - start) / 5

    # --- orjson：解析 → 修改 → 序列化 ---
    print("正在测试 orjson（完整流程）...")
    start = time.perf_counter()
    for _ in range(5):
        data = orjson.loads(json_str)
        for item in data:
            item["grade"] = "A" if item["score"] >= 90 else "B"
        new_json = orjson.dumps(data)
    orjson_time = (time.perf_counter() - start) / 5

    # --- simdjson：解析 → 转 dict → 修改 → 序列化 ---
    print("正在测试 simdjson（完整流程，含 .as_list()）...")
    start = time.perf_counter()
    for _ in range(5):
        parser = simdjson.Parser()
        obj = parser.parse(json_str)
        data = obj.as_list()  # 转为可修改的 Python 对象
        for item in data:
            item["grade"] = "A" if item["score"] >= 90 else "B"
        new_json = json.dumps(data, ensure_ascii=False)
    simd_time = (time.perf_counter() - start) / 5

    # --- 结果 ---
    print("\n📊 完整 ETL 流程性能对比结果（解析 + 修改 + 序列化）:")
    print(f"标准 json 平均时间：{std_time:.6f} 秒")
    print(f"orjson 平均时间：{orjson_time:.6f} 秒")
    print(f"simdjson 平均时间：{simd_time:.6f} 秒")
    print(f"orjson 相对加速比：{std_time / orjson_time:.2f}x")
    print(f"simdjson 相对加速比：{std_time / simd_time:.2f}x (越小越慢)")

if __name__ == "__main__":
    benchmark_etl()

正在生成测试数据... 生成完成，JSON 大小：6.25 MB 正在测试标准 json 库（完整流程）... 正在测试 orjson（完整流程）... 正在测试 simdjson（完整流程，含 .as_list()）... 📊 完整 ETL 流程性能对比结果（解析 + 修改 + 序列化）：标准 json 平均时间：0.259784 秒 orjson 平均时间：0.119655 秒 simdjson 平均时间：0.328153 秒 orjson 相对加速比：2.17x simdjson 相对加速比：0.79x (越小越慢) 

四、深入剖析：为什么 simdjson 在 ETL 中'翻车'？

1. 内存模型限制

• simdjson.Object 是对原始缓冲区的只读视图
• 无法直接赋值：obj["key"] = value 会报错
• 必须调用 .as_dict() 才能获得可修改的 Python 对象

2. .as_dict() 成本高昂

• 递归遍历整个 JSON 结构
• 为每个 key/value 创建新的 Python 对象
• 这个过程比 json.loads() 更慢（因后者是高度优化的 C 循环）

3. 无序列化能力

• 仍需依赖 json.dumps()，无法享受端到端加速

4. 对象生命周期陷阱

parser = simdjson.Parser()
obj1 = parser.parse(json1)  # OK
obj2 = parser.parse(json2)  # ❌ RuntimeError!

只要 obj1 还存在，就不能复用 parser——这在批量处理中极易出错。

五、orjson：真正的'全能选手'

orjson 在保持高性能的同时，解决了 simdjson 的关键短板：

🌟 特别提示：orjson.dumps() 返回 bytes，若需 str 可加 .decode('utf-8')，但多数场景（如写文件、HTTP 响应）直接使用 bytes 更高效。

六、选型指南：根据场景选择最佳工具

七、性能优化建议

1. 避免过早优化：先用 json，确认 JSON 是瓶颈后再替换。
2. ETL 场景首选 orjson：它在大多数真实业务中表现最佳。
3. 只读场景可考虑 simdjson：但务必确保不调用 .as_dict()/.as_list()。
4. 批量处理时复用 orjson：无需担心对象生命周期问题。
5. 输出用 bytes：orjson.dumps() 返回 bytes，直接用于网络或文件 I/O，避免额外编码。

八、结语

'快'不是绝对的，而是相对于你的使用模式。

• 如果你只是读取 JSON 并立即消费，simdjson 是王者；
• 但如果你需要修改数据并写回，orjson 才是真正的性能赢家；
• 而对于大多数普通项目，标准 json 依然是最稳妥的选择。

不要被'10 倍加速'的宣传迷惑——理解你的数据流，才是性能优化的第一步。