Python小酷库系列：Python中的JSON工具库(3)

---

在上一节“Python小酷库系列：Python中的JSON工具库(2)”中，我们主要介绍了JSON数据的校验工具，本节我们进一步来讨论在Python中比较、查询、操作JSON数据。

JSON数据的比较

在自动化测试中，我们常常需要对API 响应或程序变量进行断言，这时常常需要对前后的JSON数据进行比较，在Python中自然也不会缺少这样的比较工具。

1、jsondiff

jsondiff 是一个用于比较两个 JSON（或 Python 字典）对象差异的轻量级库。它能生成最小的变更（patch）表示，并支持将差异反向应用和还原原始数据。
安装

pip install jsondiff

基本用法

import jsondiffa = {"name": "Alice", "age": 30}
b = {"name": "Alice", "age": 31}diff = jsondiff.diff(a, b)
print(diff)  # 输出：{'age': 31}

合并与还原（补丁 patch）

patch = jsondiff.diff(a, b)
new_obj = jsondiff.patch(a, patch)  # 应用 patch 得到 b
original = jsondiff.unpatch(new_obj, patch)  # 还原为 aprint(new_obj)   # {'name': 'Alice', 'age': 31}
print(original)  # {'name': 'Alice', 'age': 30}

嵌套结构 diff

x = {"user": {"name": "Alice", "tags": ["a", "b"]}}
y = {"user": {"name": "Alice", "tags": ["a", "c"]}}print(jsondiff.diff(x, y))
# {'user': {'tags': {1: 'c'}}}  # 索引1处由'b'改为'c'

参数选项（比如忽略顺序）

a = {'numbers': [1, 2, 3]}
b = {'numbers': [3, 2, 1]}# 默认考虑顺序
print(jsondiff.diff(a, b))  
# {'numbers': jsondiff.symbols.insert: [3], 0: 3}# 忽略顺序
print(jsondiff.diff(a, b, dump=True, syntax='symmetric', sequence_matcher=jsondiff.SequenceMatcher))

2、deepdiff

比起jsondiff，deepdiff 的功能更加强大，尤其用于深度比较两个 Python 对象（特别是嵌套的 dict、list、set、tuple 等），并提供结构化的差异信息。
安装

pip install deepdiff

基本用法

from deepdiff import DeepDiffa = {"name": "Alice", "age": 30}
b = {"name": "Alice", "age": 31}diff = DeepDiff(a, b)
print(diff) # {'values_changed': {"root['age']": {'old_value': 30, 'new_value': 31}}}

差异信息说明：

键名	含义
values_changed	值发生了变化
type_changes	类型发生变化
dictionary_item_added	新增键
dictionary_item_removed	删除键
iterable_item_added	列表/集合等新增项
iterable_item_removed	列表/集合等移除项
attribute_changed	对象属性变更（如类实例）
set_item_removed/set_item_added	集合元素变更

生成和应用补丁

from deepdiff import DeepDiff, patch, unpatcha = {"x": 1}
b = {"x": 2}ddiff = DeepDiff(a, b, view='tree')
p = ddiff.patch# 应用 patch
new_data = patch(a, p)
print(new_data)  # {'x': 2}# 还原
orig = unpatch(new_data, p)
print(orig)  # {'x': 1}

差异路径与提取值

ddiff = DeepDiff(a, b, view='tree')
for diff_item in ddiff['values_changed']:print(diff_item.path(), diff_item.t1, "→", diff_item.t2)

嵌套结构 diff

a = {"user": {"name": "Alice", "roles": ["admin", "dev"]}}
b = {"user": {"name": "Alice", "roles": ["admin", "ops"]}}diff = DeepDiff(a, b)
print(diff) # {'values_changed': {"root['user']['roles'][1]": {'old_value': 'dev', 'new_value': 'ops'}}}

参数选项（比如忽略顺序，设置精度）

a = {'numbers': [1, 2, 3]}
b = {'numbers': [3, 2, 1]}diff = DeepDiff(a, b, ignore_order=True)
print(diff)  # 无差异# 浮点精度控制
diff = DeepDiff(0.3000000001, 0.3, significant_digits=7)
print(diff)  # {} 无差异

JSON数据的查询与操作

1、pyjq

pyjq 封装了 jq命令行工具，可以通过jq 表达式对 JSON 数据进行强大的模式匹配与提取、转换等操作。
安装

pip install pyjq

基本使用

import pyjqdata = {"users": [{"name": "Alice", "age": 30},{"name": "Bob", "age": 25}]
}result = pyjq.all('.users[] | select(.age > 26) | .name', data)
print(result)  # ['Alice']

常用的jq 表达式：

表达式	含义
.	原始对象本身
.field	提取字段
.[]	遍历数组
select(.field > 10)	条件筛选
map(.field)	映射数组中每一项的某字段
.{a: .field1, b: .field2}	构造新字典
`.[]	{name, age}`

嵌套结构

data = {"items": [{"id": 1, "tags": ["a", "b"]},{"id": 2, "tags": ["b", "c"]}]
}# 提取所有 tags
result = pyjq.all('.items[].tags[]', data)
print(result)  # ['a', 'b', 'b', 'c']

提取字典转为新结构

data = {"name": "Alice","profile": {"email": "a@example.com","phone": "123456"}
}result = pyjq.first('{username: .name, contact: .profile.email}', data)
print(result)  # {'username': 'Alice', 'contact': 'a@example.com'}

2、jsonpath-ng

jsonpath 是用于在 Python 中从 JSON 数据结构中提取数据的查询、操作工具，类似于 XPath 之于 XML。 jsonpath-ng（前身jsonpath）是 JSONPath 在 Python 中的主流实现库。
安装

pip install jsonpath-ng

基本使用

from jsonpath_ng import jsonpath, parsedata = {"store": {"book": [{"title": "Book A", "price": 8.95},{"title": "Book B", "price": 12.99}],"bicycle": {"color": "red","price": 19.95}}
}# 编译 JSONPath 表达式
jsonpath_expr = parse('$.store.book[*].title')# 执行匹配并提取结果
matches = jsonpath_expr.find(data)
titles = [match.value for match in matches]
print(titles)  # ['Book A', 'Book B']

常见的JSONPath 表达式：

表达式	说明
$	根节点
$.store.book	访问键路径
$.store.book[*].title	遍历数组并提取字段
$…price	递归提取所有层级的 price
$.store.book[0]	第一个数组元素
$.store.book[-1:]	最后一个元素
$.store.book[?(@.price > 10)]	条件筛选

条件查询

expr = parse('$.store.book[?(@.price > 10)].title')
matches = expr.find(data)
titles = [m.value for m in matches]
print(titles)  # ['Book B']

修改数据
可以通过 match.path.update(data, new_value) 来修改原始数据：

expr = parse('$.store.bicycle.color')
matches = expr.find(data)for match in matches:match.path.update(data, "blue")print(data["store"]["bicycle"]["color"])  # blue

提取匹配路径和值

for match in expr.find(data):print(match.path, match.value)
# Fields like Fields('store')['bicycle']['color']

JSON数据文件的操作

1、ijson

ijson 是一个用于 增量解析 JSON 文件 的 Python 库，特别适用于 大文件/流式处理。它基于迭代器，可边读边解析，不会一次性加载整个 JSON，从而节省内存。ijson 通过纯 Python 实现，也有可选的 C 扩展以提升性能。
安装

pip install ijson

基本用法
JSON数据源

{"records": {"item": [{"id": 1, "name": "Alice"},{"id": 2, "name": "Bob"}]}
}

import ijsonwith open('large_file.json', 'r') as f:for item in ijson.items(f, 'records.item'):print(item)
# {'id': 1, 'name': 'Alice'}
# {'id': 2, 'name': 'Bob'}

读取嵌套数组结构

with open('large_file.json', 'r') as f:for item in ijson.items(f, 'data.users.item'):print(item)

按需提取键值

with open('data.json', 'r') as f:for key, value in ijson.kvitems(f, 'meta'):print(f"{key} => {value}")

从网络流/HTTP/Bytes 中读取

import requests
import ijsonresponse = requests.get('https://example.com/data.json', stream=True)
for item in ijson.items(response.raw, 'users.item'):print(item)

2、jsonlines

jsonlines 是一种特殊格式的 JSON 文件，每行是一个合法的 JSON 对象，广泛用于日志、数据流、大规模数据处理（如机器学习训练集） 中。
安装

pip install jsonlines

基本用法
JSON数据源

{"id": 1, "name": "Alice"}
{"id": 2, "name": "Bob"}
{"id": 3, "name": "Charlie"}

读取 JSON Lines 文件

import jsonlineswith jsonlines.open('data.jsonl') as reader:for obj in reader:print(obj['name'])
# Alice
# Bob
# Charlie

写入 JSON Lines 文件

import jsonlinesdata = [{"id": 1}, {"id": 2}, {"id": 3}]
with jsonlines.open('output.jsonl', mode='w') as writer:writer.write_all(data)

流式写入（大数据）

with jsonlines.open('big_output.jsonl', mode='w') as writer:for i in range(1000000):writer.write({'index': i, 'square': i * i})

3、jsonpickle

jsonpickle 是一个功能强大的 Python 库，用于将 复杂的 Python 对象（如自定义类、函数、日期、NumPy、Pandas 等）序列化为 JSON，并能将其反序列化回来，它支持更多内置类型与第三方类型。
安装

pip install jsonpickle

基本使用
序列化（encode）

import jsonpickleclass Person:def __init__(self, name):self.name = nameobj = Person("Alice")# 序列化为 JSON 字符串
json_str = jsonpickle.encode(obj)
print(json_str)

反序列化（decode）

obj_restored = jsonpickle.decode(json_str)
print(obj_restored.name)  # Alice

复杂类型

import jsonpickle
import datetime
import decimaldata = {"time": datetime.datetime.now(),"score": decimal.Decimal('9.99'),"tags": {"a", "b", "c"},
}json_str = jsonpickle.encode(data)
print(json_str)restored = jsonpickle.decode(json_str)
print(restored)

保存和加载 JSON 文件

# 写入文件
with open('person.json', 'w') as f:f.write(jsonpickle.encode(obj))# 从文件读取
with open('person.json', 'r') as f:obj2 = jsonpickle.decode(f.read())

自定义 JSON处理库

jsonpickle可以指定JSON的处理库，如选择我们前面讲到的高性能库orjson。

import jsonpickle.ext.orjson as orjson
jsonpickle.set_encoder_options('orjson', option=orjson.OPT_INDENT_2)