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

在现代 Python 开发中，JSON 几乎无处不在——从 Web API 响应、配置文件到日志分析和数据管道。当数据量增大时，JSON 解析与序列化的性能往往会成为系统瓶颈。

社区中流传着各种“超快 JSON 库”的传说：simdjson 声称比标准库快 10 倍，orjson 则号称“最快的 Python JSON 库”。但这些说法是否适用于你的实际场景？“快”到底指什么？解析快？序列化快？还是整体 ETL 流程快？

本文将通过原理剖析 + 多维度实测，全面对比 Python 中三大主流 JSON 方案：

• json（Python 内置）
• simdjson（极致解析速度）
• orjson（全能型高性能选手）

并给出明确的选型建议：在什么场景下该用哪个库？

一、三大库简介

1. json（标准库）

• 语言：C 实现（CPython）
• 特点：稳定、兼容性好、API 简洁
• 适用：通用场景，无需额外依赖
• 缺点：性能一般，尤其在大数据量下

2. simdjson

• 语言：C++（底层），Python 绑定为 pysimdjson
• 核心优势：利用 SIMD 指令并行解析，纯解析速度极快
• 设计哲学：零拷贝、只读视图、延迟访问
• 限制：不可修改、无序列化、对象生命周期敏感

3. orjson

• 语言：Rust 编写，通过 PyO3 提供 Python 绑定
• 定位：高性能且功能完整的替代方案
• 优势：
  • 解析和序列化都快
  • 返回原生 dict/list，可直接修改
  • 支持 datetime、numpy、UUID 等类型
  • 输出为 bytes，减少编码开销

💡 安装方式：

pip install simdjson orjson

二、测试场景设计

我们设计两个典型场景进行 benchmark：

场景 A：纯解析（只读）

仅解析 JSON，不做任何修改或序列化
→ 适合日志分析、指标提取等场景

场景 B：完整 ETL（读 → 改 → 写）

测试数据：5 万条结构化记录（约 9 MB）

三、测试代码与结果

📌 场景 A：纯解析性能对比

import json
import time
import simdjson
import orjson
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_pure_parse():
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)
_ = simdjson.Parser().parse(small_json)
_ = orjson.loads(small_json)

# — 标准 json —
print("正在测试标准 json 库（仅解析）…")
start = time.perf_counter()
for _ in range(5):
obj = json.loads(json_str)
std_time = (time.perf_counter() – start) / 5

# — simdjson —
print("正在测试 simdjson（仅解析）…")
start = time.perf_counter()
for _ in range(5):
parser = simdjson.Parser()
obj = parser.parse(json_str) # 注意：不调用 .as_dict()
simd_time = (time.perf_counter() – start) / 5

# — orjson —
print("正在测试 orjson（仅解析）…")
start = time.perf_counter()
for _ in range(5):
obj = orjson.loads(json_str)
orjson_time = (time.perf_counter() – start) / 5

# — 结果 —
print("\\n📊 纯解析性能对比结果:")
print(f"标准 json 平均时间: {std_time:.6f} 秒")
print(f"simdjson 平均时间: {simd_time:.6f} 秒")
print(f"orjson 平均时间: {orjson_time:.6f} 秒")
print(f"simdjson 加速比: {std_time / simd_time:.2f}x")
print(f"orjson 加速比: {std_time / orjson_time:.2f}x")

if __name__ == "__main__":
benchmark_pure_parse()

正在生成测试数据…
生成完成，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 更高效。

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

七、性能优化建议

八、结语

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

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

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