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数据，核心其实就两点：把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的缩写）就派上用场了。它直接接受一个文件对象作为参数，省去了先读取文件内容再解析字符串的步骤，效率上会更好一些，也更符合文件操作的习惯。
立即学习“Python免费学习笔记（深入）”；
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只支持有限的数据类型：字符串、数字、布尔值、
、对象（字典）和数组（列表）。像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
参数处理自定义类型。
评论（已关闭）
评论已关闭