Python JSON数据处理全攻略：35个实战技巧覆盖全场景

图：Python 标志

在当今的软件开发中，JSON（JavaScript Object Notation）已成为事实上的标准数据交换格式。Python 凭借其内置的 json 模块和丰富的第三方库生态，为处理 JSON 数据提供了全面而强大的支持。本文将为你系统梳理 35 个 Python 处理 JSON 的实战方法，涵盖从基础解析到高级应用、从文件操作到性能优化的各种场景，助你提升开发效率。

1. 解析JSON字符串为字典

使用场景：解析从网络接口、消息队列或前端传来的 JSON 字符串。

import json

json_str = '{"name": "张三", "age": 25}'
data_dict = json.loads(json_str)
print(data_dict['name'])  # 输出：张三

2. 字典序列化为JSON字符串

使用场景：构建 API 请求体或封装接口响应。

data_dict = {"username": "testuser", "password": "123456"}
json_str = json.dumps(data_dict, ensure_ascii=False)  # ensure_ascii=False确保中文正常显示
print(json_str)  # 输出：{"username": "testuser", "password": "123456"}

3. 格式化输出：生成美观的JSON字符串

使用场景：生成易于阅读的日志或配置文件。

data = {"b": 2, "a": 1, "c": 3}
pretty_json = json.dumps(data, indent=4, sort_keys=True, ensure_ascii=False)
print(pretty_json)

4. 处理日期时间等非标准对象

使用场景：序列化包含 datetime 对象等 Python 特有类型的字典。

from datetime import datetime

def custom_serializer(obj):
    if isinstance(obj, datetime):
        return obj.isoformat()
    raise TypeError(f"Type {type(obj)} not serializable")

data = {"event": "meeting", "time": datetime.now()}
json_str = json.dumps(data, default=custom_serializer, ensure_ascii=False)
print(json_str)

5. 读取JSON文件

使用场景：加载配置文件、测试数据。

with open('config.json', 'r', encoding='utf-8') as f:
    config = json.load(f)
    print(config)

6. 写入JSON文件

使用场景：保存程序运行结果、用户数据。

result = {"status": "success", "data": [1, 2, 3]}
with open('output.json', 'w', encoding='utf-8') as f:
    json.dump(result, f, indent=2, ensure_ascii=False)

7. 增量写入大型JSON文件

使用场景：处理海量数据，无法一次性加载到内存。

# 假设有一个巨大的数据列表，逐条写入
big_data = [{"id": i, "value": f"item_{i}"} for i in range(1000000)]
with open('large_data.jsonl', 'w', encoding='utf-8') as f:  # 使用JSON Lines格式
    for item in big_data:
        f.write(json.dumps(item, ensure_ascii=False) + '\n')

8. 提取嵌套字段

使用场景：从 API 返回的深层结构中提取如 token、用户 ID 等关键信息。

data = {"code": 200, "data": {"user": {"id": 1, "name": "李四"}}}
user_name = data["data"]["user"]["name"]
print(user_name)  # 输出：李四

9. 安全访问与默认值

使用场景：访问可能不存在的字段，避免 KeyError。

data = {"user": {"name": "王五"}}
email = data.get("user", {}).get("email", "未填写")
print(email)  # 输出：未填写

10. 使用jsonpath-ng进行高级查询

使用场景：适用于对多层嵌套、结构复杂的 JSON 进行类似 XPath 的路径查询。

from jsonpath_ng import parse

data = {
    "store": {
        "book": [
            {"title": "Book A", "price": 20},
            {"title": "Book B", "price": 30}
        ]
    }
}
jsonpath_expr = parse("$.store.book[?(@.price > 25)].title")
matches = [match.value for match in jsonpath_expr.find(data)]
print(matches)  # 输出：['Book B']

提示：需先安装库 pip install jsonpath-ng.

11. 遍历所有键值对

使用场景：调试或记录整个数据结构。

data = {"status": "ok", "count": 5}
for key, value in data.items():
    print(f"{key}: {value}")

12. 判断键是否存在

使用场景：断言接口响应是否包含预期字段。

if "status" in data:
    print("包含状态字段")

13. 添加新字段

使用场景：动态构造请求参数，如添加时间戳、会话 ID。

data = {"user": "admin"}
data["timestamp"] = "2025-12-25T10:30:00"

14. 删除字段

使用场景：清理敏感信息（如密码）或不需要的数据。

data = {"username": "test", "password": "secret", "age": 20}
data.pop("password", None)  # 使用pop更安全

15. 修改字段值

使用场景：更新配置或数据状态。

data["user"]["name"] = "新的名字"

16. 合并两个JSON对象

使用场景：合并多个来源的配置或数据。

dict1 = {"a": 1}
dict2 = {"b": 2}
merged = {**dict1, **dict2}  # Python 3.5+
# 或使用 dict1.update(dict2)

17. 深度合并（递归合并）

使用场景：合并嵌套的配置字典。

def deep_merge(a, b):
    for key in b:
        if key in a and isinstance(a[key], dict) and isinstance(b[key], dict):
            deep_merge(a[key], b[key])
        else:
            a[key] = b[key]
    return a

base_config = {"db": {"host": "localhost"}}
override = {"db": {"port": 5432}}
final_config = deep_merge(base_config, override)

18. 键名风格转换

使用场景：对接不同语言的后端（如 Java 的 camelCase 转 Python 的 snake_case）。

import re

def camel_to_snake(name):
    name = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', name).lower()

data = {"userName": "Tom", "orderId": 100}
snake_data = {camel_to_snake(k): v for k, v in data.items()}
print(snake_data)  # 输出：{'user_name': 'Tom', 'order_id': 100}

19. 过滤JSON列表

使用场景：从用户列表中筛选出成年人。

users = [{"name": "Alice", "age": 25}, {"name": "Bob", "age": 17}]
adults = [u for u in users if u['age'] >= 18]

20. 列表排序

使用场景：按某个字段对结果进行排序。

sorted_users = sorted(users, key=lambda x: x['age'], reverse=True)

21. 数据映射转换

使用场景：提取对象列表中的特定字段，或进行格式转换。

names = list(map(lambda x: x['name'], users))
# 或使用列表推导式: names = [u['name'] for u in users]

22. 使用Pandas进行复杂处理

使用场景：对 JSON 数据进行类似 SQL 的查询、分组、聚合。

import pandas as pd

df = pd.DataFrame(users)
# 筛选并计算平均年龄
avg_age = df[df['age'] >= 18]['age'].mean()
print(f"成年人平均年龄: {avg_age}")

提示：需先安装库 pip install pandas。

23. 校验JSON格式

使用场景：验证字符串是否为有效的 JSON。

def is_valid_json(json_str):
    try:
        json.loads(json_str)
        return True
    except json.JSONDecodeError:
        return False

24. 比较两个JSON是否相等

使用场景：断言接口响应与预期结果一致。

def json_equal(a, b):
    return json.dumps(a, sort_keys=True) == json.dumps(b, sort_keys=True)

25. 查找差异（使用deepdiff）

使用场景：精确找出两个复杂 JSON 结构之间的不同之处。

from deepdiff import DeepDiff

expected = {"a": 1, "b": {"c": 2}}
actual = {"a": 1, "b": {"c": 3}}
diff = DeepDiff(expected, actual)
print(diff)  # 输出：{'values_changed': {"root['b']['c']": {'new_value': 3, 'old_value': 2}}}

提示：需先安装库 pip install deepdiff。

26. 使用tabulate美化打印

使用场景：在控制台以表格形式清晰展示 JSON 列表数据。

from tabulate import tabulate

data = [{"name": "Alice", "age": 25}, {"name": "Bob", "age": 17}]
print(tabulate(data, headers="keys", tablefmt="grid"))

提示：需先安装库 pip install tabulate。

27. 使用pprint格式化打印

使用场景：调试时更美观地打印任何 Python 数据结构（包括字典/列表）。

from pprint import pprint

complex_data = {"a": [1,2,3], "b": {"c": {"d": "deep"}}}
pprint(complex_data, indent=2, width=50)

28. 使用requests库处理API JSON

使用场景：发送 JSON 请求并解析 JSON 响应。

import requests

# 发送JSON请求体
resp = requests.post(' https://api.example.com/login',
                     json={"user": "test", "pwd": "123"})
# 自动将响应内容解析为字典
data = resp.json()
if data.get('code') == 200:
    token = data['data']['token']

29. 模拟API响应（Mock）

使用场景：单元测试或开发前期，模拟后端接口。

from unittest.mock import Mock

def mock_user_api():
    mock_resp = Mock()
    mock_resp.json.return_value = {"id": 1, "name": "Mock User"}
    mock_resp.status_code = 200
    return mock_resp

# 在测试中使用 mock_resp

30. 使用FastAPI提供JSON API

使用场景：快速构建一个返回 JSON 的 Web 服务。

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.post("/items/")
def create_item(item: Item):
    # item 自动被解析为Pydantic模型
    return {"message": f"Item {item.name} created", "price": item.price}

# 运行后，该端点自动接收和返回JSON

提示：需先安装库 pip install fastapi uvicorn。

31. 错误处理与异常捕获

使用场景：增强代码健壮性，处理网络超时、数据格式错误等异常。

import json
import requests
from requests.exceptions import Timeout

def safe_json_request(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()  # 检查HTTP错误
        return response.json()
    except Timeout:
        print("请求超时")
        return None
    except json.JSONDecodeError:
        print("响应不是有效的JSON格式")
        return None
    except KeyError as e:
        print(f"缺少必要字段: {e}")
        return None

32. JSON Schema校验

使用场景：在接口测试或数据入库前，对 JSON 结构进行强校验。

from jsonschema import validate, ValidationError

# 定义schema
user_schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0}
    },
    "required": ["name", "age"]
}

# 待校验数据
user_data = {"name": "张三", "age": 25}

try:
    validate(instance=user_data, schema=user_schema)
    print("数据校验通过")
except ValidationError as e:
    print(f"数据校验失败: {e.message}")

提示：需先安装库 pip install jsonschema。

33. 性能优化：流式处理大型JSON

使用场景：处理超大型 JSON 文件，避免内存溢出。

import ijson

def process_large_json(file_path):
    with open(file_path, 'rb') as f:
        # 流式解析，逐条处理
        for item in ijson.items(f, 'item'):
            # 处理每条数据
            process_item(item)

提示：需先安装库 pip install ijson。

34. 与NoSQL数据库交互

使用场景：将 JSON 数据直接存储到 MongoDB 等 NoSQL 数据库。

from pymongo import MongoClient

# 连接MongoDB
client = MongoClient('localhost', 27017)
db = client['mydatabase']
collection = db['users']

# 插入JSON数据
user_data = {"name": "张三", "age": 25, "email": "zhangsan@example.com"}
result = collection.insert_one(user_data)
print(f"插入文档ID: {result.inserted_id}")

# 查询JSON数据
query_result = collection.find_one({"name": "张三"})
print(f"查询结果: {query_result}")

提示：需先安装库 pip install pymongo。

35. JSON序列化自定义对象

使用场景：序列化包含自定义类的复杂对象。

import json
from datetime import datetime

class User:
    def __init__(self, name, join_date):
        self.name = name
        self.join_date = join_date

    def to_dict(self):
        return {
            "name": self.name,
            "join_date": self.join_date.isoformat()
        }

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, User):
            return obj.to_dict()
        elif isinstance(obj, datetime):
            return obj.isoformat()
        return super().default(obj)

# 使用自定义编码器
user = User("张三", datetime.now())
json_str = json.dumps(user, cls=CustomEncoder, ensure_ascii=False)
print(json_str)

总结与场景应用

本文系统介绍了 Python 处理 JSON 的 35 个实用方法，从基础的 json.loads/dumps 到结合 requests、pandas、jsonpath-ng 等库的高级应用。通过灵活组合这些方法，你将能够高效、优雅地处理各种 JSON 数据处理任务，提升开发效率与代码质量。

掌握这些方法将能轻松应对以下场景：

• 接口开发与测试：使用 requests 发送/接收 JSON，结合 Mock 进行单元测试。
• 数据清洗与转换：利用 Pandas 进行复杂处理，使用 jsonpath-ng 进行高级查询。
• 配置文件管理：安全读写 JSON 配置文件，支持深度合并和键名转换。
• Web服务开发：使用 FastAPI 快速构建 RESTful API。
• 大数据处理：通过流式处理和增量写入应对海量数据。
• 数据校验与调试：使用 JSON Schema 进行结构校验，利用 deepdiff 比较差异。

如果你希望深入系统地学习 Python 的各个方面，包括更多数据处理技巧和 Web 开发框架，可以访问 云栈社区的 Python 技术板块，那里有丰富的教程和开发者讨论。

正所谓“无他，惟手熟尔”！有需要的用起来！