当前位置：首页 > 文章列表 > 文章 > python教程 > Python轻松解析JSON数据技巧

Python轻松解析JSON数据技巧

2025-10-28 08:32:59 0浏览收藏

哈喽！大家好，很高兴又见面了，我是golang学习网的一名作者，今天由我给大家带来一篇《Python解析JSON数据技巧分享》，本文主要会讲到等等知识点，希望大家一起学习进步，也欢迎大家关注、点赞、收藏、转发! 下面就一起来看看吧！

Python解析JSON核心是使用json模块的loads、load、dumps和dump函数，实现字符串与文件的相互转换。1. json.loads()将JSON字符串转为Python对象，适用于API响应等字符串数据；2. json.load()直接从文件读取并解析JSON；3. json.dumps()将Python对象转为JSON字符串，可设置indent美化输出、ensure_ascii=False支持中文；4. json.dump()将数据写入JSON文件。处理嵌套数据时，可通过键链访问，推荐使用dict.get()避免KeyError。对于缺失字段或类型错误，结合get()与try-except可提升健壮性。序列化时若遇非JSON兼容类型（如datetime、自定义类），需手动转换或使用default参数定义处理函数。sort_keys=True可按键排序输出，确保一致性。掌握类型映射与异常处理是高效处理JSON的关键。

Python怎么解析JSON数据_PythonJSON处理技巧总结

Python解析JSON数据，核心其实就两点：把JSON字符串变成Python对象，或者把Python对象变成JSON字符串。Python标准库里的json模块就是干这个的，它提供了loads、load、dumps和dump这几个函数，分别对应从字符串加载、从文件加载、序列化到字符串和序列化到文件。大多数时候，我们用json.loads()来处理接收到的JSON文本，它能把JSON对象映射成Python字典，JSON数组映射成Python列表，布尔值、数字和字符串也都有对应的Python类型。

解决方案

处理JSON数据，我们主要围绕json模块的四个核心函数展开。

当你拿到的是一个JSON格式的字符串时，比如从API请求返回的响应体，最直接的方式就是使用json.loads()（load string的缩写）。它会尝试解析这个字符串，并将其转换为对应的Python数据结构，通常是字典或列表。

import json

json_string = '{"name": "张三", "age": 30, "isStudent": false, "courses": ["数学", "英语"]}'
try:
    data = json.loads(json_string)
    print(f"解析后的数据类型: {type(data)}")
    print(f"姓名: {data['name']}, 年龄: {data['age']}")
except json.JSONDecodeError as e:
    print(f"JSON解析错误: {e}")
except KeyError as e:
    print(f"访问键错误: {e}")

如果你的JSON数据是存储在一个文件中，那么json.load()（load file的缩写）就派上用场了。它直接接受一个文件对象作为参数，省去了先读取文件内容再解析字符串的步骤，效率上会更好一些，也更符合文件操作的习惯。

import json

# 假设有一个名为 'data.json' 的文件
# 内容可能是: {"city": "北京", "population": 21000000}
try:
    with open('data.json', 'r', encoding='utf-8') as f:
        file_data = json.load(f)
        print(f"从文件加载的数据: {file_data}")
except FileNotFoundError:
    print("文件 'data.json' 不存在。")
except json.JSONDecodeError as e:
    print(f"文件中的JSON解析错误: {e}")

反过来，如果你想把Python字典或列表等数据结构保存成JSON格式的字符串或文件，json.dumps()和json.dump()是对应的工具。json.dumps()（dump string）会返回一个JSON格式的字符串，而json.dump()（dump file）则直接写入到文件对象中。

import json

python_data = {
    "product": "笔记本电脑",
    "price": 8999.00,
    "specs": {"cpu": "i7", "ram_gb": 16},
    "available": True
}

# 序列化为字符串
json_output_string = json.dumps(python_data, indent=4, ensure_ascii=False)
print("\n序列化后的JSON字符串:")
print(json_output_string)

# 序列化到文件
try:
    with open('output.json', 'w', encoding='utf-8') as f:
        json.dump(python_data, f, indent=4, ensure_ascii=False)
    print("\n数据已成功写入 'output.json' 文件。")
except IOError as e:
    print(f"文件写入错误: {e}")

这里特别提一下indent=4，它能让输出的JSON字符串或文件内容进行“美化”，带上缩进，这样可读性会大大提高，调试的时候尤其有用。ensure_ascii=False则确保非ASCII字符（比如中文）能够直接显示，而不是被转义成\uXXXX的形式。

如何高效地访问和处理嵌套JSON数据？

在实际工作中，我们很少遇到扁平化的JSON，更多的是层层嵌套的复杂结构，比如一个订单对象里包含客户信息、商品列表，商品列表里每个商品又有自己的属性。处理这种数据，最直接的办法就是像访问Python字典和列表一样，通过键和索引逐层深入。

import json

complex_json_string = """
{
    "orderId": "A12345",
    "customer": {
        "id": "C001",
        "name": "李华",
        "address": {
            "street": "科技园路1号",
            "city": "深圳"
        }
    },
    "items": [
        {"itemId": "P001", "name": "键盘", "price": 299.0, "quantity": 1},
        {"itemId": "P002", "name": "鼠标", "price": 99.0, "quantity": 2}
    ],
    "totalAmount": 497.0
}
"""

data = json.loads(complex_json_string)

# 访问嵌套数据
customer_name = data['customer']['name']
customer_city = data['customer']['address']['city']
first_item_name = data['items'][0]['name']
second_item_quantity = data['items'][1]['quantity']

print(f"客户姓名: {customer_name}")
print(f"客户所在城市: {customer_city}")
print(f"第一个商品: {first_item_name}")
print(f"第二个商品的数量: {second_item_quantity}")

# 遍历商品列表
print("\n订单商品详情:")
for item in data['items']:
    print(f"  - {item['name']} (ID: {item['itemId']}), 价格: {item['price']}, 数量: {item['quantity']}")

这种直接访问的方式对于结构相对固定且层级不深的数据很有效。但如果JSON结构非常深，或者某些键可能存在或不存在，直接链式访问就容易遇到KeyError。这时候，我会倾向于使用dict.get()方法，它允许你指定一个默认值，如果键不存在，就不会抛出错误，而是返回这个默认值。

# 使用 .get() 访问，避免 KeyError
# 假设有时 'address' 可能不存在
customer_address_street = data.get('customer', {}).get('address', {}).get('street', '未知街道')
print(f"客户街道 (使用.get()): {customer_address_street}")

# 假设有时 'shippingAddress' 可能不存在
shipping_city = data.get('shippingAddress', {}).get('city', '未提供')
print(f"收货城市 (使用.get()): {shipping_city}")

对于那些结构不固定，或者你需要处理任意深度的嵌套数据，递归函数是一个强大的工具。例如，如果你想找到JSON中所有特定名称的键对应的值，无论它们在哪个层级，递归就能派上用场。不过，这通常在数据探索或特定数据清洗场景下才会用到，日常解析大部分还是通过已知路径访问。

如何优雅地处理JSON数据中的缺失键或类型不匹配问题？

处理JSON数据时，最让人头疼的莫过于数据不完整或者类型不一致。API返回的数据可能今天有这个字段，明天就没了；或者本来应该是数字，结果传了个字符串过来。如果直接访问，轻则KeyError，重则TypeError，直接导致程序崩溃。

前面提到的dict.get(key, default_value)是解决缺失键问题的黄金法则。它不仅让代码更健壮，也避免了大量的if key in dict:判断。

import json

user_data_string = '{"id": "U001", "name": "王五", "email": "wangwu@example.com"}'
user_data = json.loads(user_data_string)

# 尝试获取一个可能不存在的字段
phone_number = user_data.get('phone', '未提供')
print(f"用户电话: {phone_number}")

# 尝试获取一个存在的字段
email = user_data.get('email', '无邮箱信息')
print(f"用户邮箱: {email}")

对于类型不匹配，或者说我们期望某个字段是特定类型但实际不是的情况，try-except块是你的好朋友。你可以尝试将获取到的值转换为期望的类型，如果转换失败（比如尝试将一个非数字字符串转换为整数），就捕获ValueError。

import json

product_info_string = '{"productId": "P003", "price": "199.50", "stock": "abc"}'
product_info = json.loads(product_info_string)

product_id = product_info.get('productId')

# 尝试转换价格为浮点数
price = None
try:
    price = float(product_info.get('price'))
except (ValueError, TypeError):
    print(f"警告: 商品ID {product_id} 的价格数据格式不正确，使用默认值 0.0。")
    price = 0.0

# 尝试转换库存为整数
stock = None
try:
    stock = int(product_info.get('stock'))
except (ValueError, TypeError):
    print(f"警告: 商品ID {product_id} 的库存数据格式不正确，使用默认值 0。")
    stock = 0

print(f"商品ID: {product_id}, 价格: {price}, 库存: {stock}")

这种方式虽然有效，但当字段很多时，代码会变得冗长。对于更复杂的场景，比如需要严格验证数据结构和类型，可以考虑引入一些第三方库，例如Pydantic。Pydantic允许你用Python的类型提示来定义数据模型，它会在数据加载时自动进行验证和类型转换，大大简化了数据处理的复杂性，并且错误信息也更友好。不过，如果只是偶尔处理几个字段，手动get()和try-except已经足够。

将Python对象序列化为JSON时需要注意什么？

将Python对象转换为JSON格式，也就是序列化，看似简单，但也有一些需要留心的地方。最常见的问题就是TypeError: Object of type X is not JSON serializable。这是因为JSON只支持有限的数据类型：字符串、数字、布尔值、null、对象（字典）和数组（列表）。像Python的datetime对象、set集合、自定义类的实例，它们都没有直接对应的JSON类型，所以json模块不知道怎么处理。

遇到这种情况，我们有几种处理方式：

手动转换：在序列化之前，将不支持的类型手动转换为JSON支持的类型。比如datetime对象可以转换为ISO格式的字符串。

import json
from datetime import datetime

data_with_datetime = {
    "event_name": "会议",
    "event_time": datetime.now(), # datetime对象
    "participants": ["Alice", "Bob"]
}

# 错误示例：直接序列化会报错
# json.dumps(data_with_datetime)

# 正确做法：手动转换为字符串
data_with_datetime['event_time'] = data_with_datetime['event_time'].isoformat()
json_output = json.dumps(data_with_datetime, indent=4, ensure_ascii=False)
print("手动转换datetime后的JSON:")
print(json_output)

使用default参数：json.dumps()和json.dump()都接受一个default参数，它是一个函数。当序列化器遇到无法处理的对象时，会调用这个函数，并将该对象作为参数传给它。你可以在这个函数里定义如何将特定类型的对象转换为可序列化的形式。

import json
from datetime import datetime, date

class MyCustomClass:
    def __init__(self, value):
        self.value = value

def custom_serializer(obj):
    if isinstance(obj, (datetime, date)):
        return obj.isoformat()
    if isinstance(obj, MyCustomClass):
        return {"_custom_class_value": obj.value} # 将自定义对象转换为字典
    raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")

complex_data = {
    "created_at": datetime.now(),
    "today": date.today(),
    "my_object": MyCustomClass("hello custom!"),
    "numbers": {1, 2, 3} # set类型
}

# 序列化时指定 default 函数
try:
    json_output = json.dumps(complex_data, indent=4, ensure_ascii=False, default=custom_serializer)
    print("\n使用default参数处理后的JSON:")
    print(json_output)
except TypeError as e:
    print(f"序列化错误 (default函数未处理): {e}")

这里需要注意，default函数应该返回一个JSON可序列化的对象，否则会继续抛出TypeError。

indent和ensure_ascii：这两个参数我在前面也提到了。indent用于美化输出，让JSON文件或字符串更易读；ensure_ascii=False则允许输出非ASCII字符（如中文）的原始形式，而不是\uXXXX转义序列，这对于日志记录或直接在浏览器中查看JSON非常有用。
sort_keys：当设置为True时，json.dumps()会按照键的字母顺序对字典进行排序。这对于需要生成一致性JSON输出的场景非常有用，比如在测试或缓存键生成时。
```
data_to_sort = {"b": 2, "a": 1, "c": 3}
sorted_json = json.dumps(data_to_sort, sort_keys=True, indent=4)
print("\n按键排序后的JSON:")
print(sorted_json)
```
如果不排序，Python字典的迭代顺序在Python 3.7+是保持插入顺序的，但在老版本或某些特定操作后可能不固定，所以sort_keys能提供更强的确定性。

掌握这些技巧，基本上就能应对Python中JSON数据的解析和序列化任务了。关键在于理解JSON与Python数据类型的映射关系，并学会用get()和try-except来增强代码的健壮性，以及利用default参数处理自定义类型。

到这里，我们也就讲完了《Python轻松解析JSON数据技巧》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于json.loads(),json.dumps(),json模块,dict.get(),default参数的知识点！

json.loads() json.dumps() json模块 dict.get() default参数