python如何比较json串

Python如何比较JSON串：实用方法与技巧

在Python开发中,JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，被广泛应用于API接口、配置文件、数据存储等场景，无论是验证API返回数据是否符合预期，还是比对两个配置文件的差异，比较JSON串都是常见需求，本文将详细介绍Python中比较JSON串的多种方法，从基础到进阶，涵盖不同场景下的实用技巧。

直接比较：JSON字符串的完全匹配

如果两个JSON串在字符串层面完全一致（包括空格、换行、键的顺序等），直接使用字符串比较即可，Python的运算符可以判断两个字符串是否完全相同。

示例

json_str1 = '{"name": "Alice", "age": 25, "city": "New York"}'
json_str2 = '{"name": "Alice", "age": 25, "city": "New York"}'
json_str3 = '{"name": "Bob", "age": 30, "city": "London"}'
print(json_str1 == json_str2)  # 输出: True（完全匹配）
print(json_str1 == json_str3)  # 输出: False（内容不同）

注意事项

JSON标准中,键的顺序不影响数据语义，但字符串比较会区分顺序。
{"name": "Alice", "age": 25} 和 {"age": 25, "name": "Alice"} 在字符串层面不相等，但数据内容是等价的。
空格、换行、缩进等格式差异会导致字符串比较失败。
{"name": "Alice"} 和 {\n "name": "Alice"\n} 在字符串层面不相等。

解析后比较：基于Python字典的深度比较

JSON串的本质是Python中的字典（dict）和列表（list）的组合，通过json模块将JSON字符串解析为Python对象后，可以基于数据结构本身进行比较，忽略格式差异（如空格、键顺序等）。

使用`json.loads()`解析并直接比较

json.loads()将JSON字符串转换为Python字典/列表，此时运算符会递归比较嵌套结构的每个元素。

示例

import json
json_str1 = '{"name": "Alice", "age": 25, "city": "New York"}'
json_str2 = '{"age": 25, "name": "Alice", "city": "New York"}'  # 键顺序不同
json_str3 = '{"name": "Alice", "age": "25", "city": "New York"}'  # age类型为字符串
data1 = json.loads(json_str1)
data2 = json.loads(json_str2)
data3 = json.loads(json_str3)
print(data1 == data2)  # 输出: True（忽略键顺序，数据内容相同）
print(data1 == data3)  # 输出: False（age类型不同：int vs str）

处理数据类型差异

JSON中,数字默认解析为Python的int或float，布尔值为True/False，null为None，如果需要忽略数据类型差异（例如25和"25"视为相同），需手动处理。

示例：统一数据类型后比较

def normalize_value(value):
    """将值转换为字符串以忽略类型差异"""
    if isinstance(value, (int, float, bool, type(None))):
        return str(value)
    return value
def compare_json_types_ignored(data1, data2):
    """递归比较JSON数据，忽略类型差异"""
    if isinstance(data1, dict) and isinstance(data2, dict):
        if set(data1.keys()) != set(data2.keys()):
            return False
        for key in data1:
            if not compare_json_types_ignored(normalize_value(data1[key]), normalize_value(data2[key])):
                return False
        return True
    elif isinstance(data1, list) and isinstance(data2, list):
        if len(data1) != len(data2):
            return False
        for v1, v2 in zip(data1, data2):
            if not compare_json_types_ignored(normalize_value(v1), normalize_value(v2)):
                return False
        return True
    else:
        return normalize_value(data1) == normalize_value(data2)
json_str1 = '{"age": 25}'
json_str2 = '{"age": "25"}'
data1, data2 = json.loads(json_str1), json.loads(json_str2)
print(compare_json_types_ignored(data1, data2))  # 输出: True（忽略类型差异）

忽略特定字段比较：部分匹配

实际场景中,有时需要忽略某些字段（如时间戳、ID、版本号等）进行比较，可以通过以下方法实现：

解析后删除指定字段再比较

import json
json_str1 = '{"id": 1, "name": "Alice", "timestamp": "2023-01-01"}'
json_str2 = '{"id": 2, "name": "Alice", "timestamp": "2023-01-02"}'  # id和timestamp不同
data1, data2 = json.loads(json_str1), json.loads(json_str2)
# 忽略"id"和"timestamp"字段
for key in ["id", "timestamp"]:
    data1.pop(key, None)
    data2.pop(key, None)
print(data1 == data2)  # 输出: True（仅比较"name"字段）

动态指定忽略字段

def compare_json_ignore_fields(json_str1, json_str2, ignore_fields):
    """比较两个JSON串，忽略指定字段"""
    data1, data2 = json.loads(json_str1), json.loads(json_str2)
    for field in ignore_fields:
        data1.pop(field, None)
        data2.pop(field, None)
    return data1 == data2
json_str1 = '{"user": "Alice", "role": "admin", "login_time": "12:00:00"}'
json_str2 = '{"user": "Alice", "role": "admin", "login_time": "13:00:00"}'
ignore_fields = ["login_time"]
print(compare_json_ignore_fields(json_str1, json_str2, ignore_fields))  # 输出: True

结构化比较：差异分析与输出

除了判断是否相等,有时还需要输出具体的差异字段（如哪个键的值不同、哪些键缺失等），可以通过递归遍历结构实现，或使用第三方库简化操作。

手动实现差异分析

def find_json_diff(data1, data2, path=""):
    """递归查找两个JSON数据的差异"""
    if type(data1) != type(data2):
        return f"{path}: 类型不同 ({type(data1).__name__} vs {type(data2).__name__})"
    if isinstance(data1, dict):
        diff = []
        all_keys = set(data1.keys()) | set(data2.keys())
        for key in all_keys:
            new_path = f"{path}.{key}" if path else key
            if key not in data1:
                diff.append(f"{new_path}: 在JSON1中缺失")
            elif key not in data2:
                diff.append(f"{new_path}: 在JSON2中缺失")
            else:
                diff.extend(find_json_diff(data1[key], data2[key], new_path))
        return diff
    elif isinstance(data1, list):
        if len(data1) != len(data2):
            return f"{path}: 列表长度不同 ({len(data1)} vs {len(data2)})"
        diff = []
        for i, (v1, v2) in enumerate(zip(data1, data2)):
            diff.extend(find_json_diff(v1, v2, f"{path}[{i}]"))
        return diff
    else:
        if data1 != data2:
            return f"{path}: 值不同 ({data1} vs {data2})"
        return []
json_str1 = '{"name": "Alice", "scores": [90, 85], "info": {"age": 25}}'
json_str2 = '{"name": "Bob", "scores": [90, 88], "info": {"age": 26}}'
data1, data2 = json.loads(json_str1), json.loads(json_str2)
diffs = find_json_diff(data1, data2)
if diffs:
    print("差异如下：")
    for diff in diffs:
        print(diff)
else:
    print("JSON数据完全相同")

输出结果

差异如下：
.name: 值不同 (Alice vs Bob)
.scores[1]: 值不同 (85 vs 88)
.info.age: 值不同 (25 vs 26)

使用第三方库`deepdiff`

deepdiff是一个强大的Python库，专门用于深度比较复杂数据结构，支持忽略路径、类型、顺序等差异，输出格式友好。

正文

python如何比较json串