Python 35个JSON数据处理方法

用户11081884

发布于 2026-07-20 19:14:52

810

软件开发中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的30+个实用方法，从基础的json.loads/dumps到结合requests、pandas、jsonpath-ng等库的高级应用。通过灵活组合这些方法，将能够高效、优雅地处理各种JSON数据处理任务，提升开发效率与代码质量。掌握这些方法将能轻松应对以下场景：

1、接口开发与测试：使用requests发送/接收JSON，结合Mock进行单元测试

2、数据清洗与转换：利用Pandas进行复杂处理，使用jsonpath-ng进行高级查询

3、配置文件管理：安全读写JSON配置文件，支持深度合并和键名转换

4、Web服务开发：使用FastAPI快速构建RESTful API

5、大数据处理：通过流式处理和增量写入应对海量数据

6、数据校验与调试：使用JSON Schema进行结构校验，利用deepdiff比较差异

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

如果你觉得这篇文章有用，欢迎点赞、转发、收藏、留言、推荐❤！

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2025-12-26，如有侵权请联系 cloudcommunity@tencent.com 删除

对象

本文分享自 Nicholas与Pypi 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度