python如何处理json数据_python JSON数据解析与生成指南

裘德小鎮的故事

发布时间：2025-09-12 13:47:01

841人浏览过

来源于php中文网

原创

Python通过json模块实现JSON数据的序列化与反序列化，核心函数包括json.loads()、json.load()、json.dumps()和json.dump()，支持数据类型映射、文件读写及错误处理；对于大型JSON文件，推荐使用ijson库进行流式解析以降低内存占用；自定义对象可通过default函数或继承JSONEncoder/Decoder实现序列化与反序列化，确保复杂数据结构的完整转换。

python如何处理json数据_python json数据解析与生成指南

Python处理JSON数据主要依赖其内置的

json

模块，这个模块提供了将Python对象转换为JSON格式字符串（序列化）以及将JSON格式字符串转换回Python对象（反序列化）的核心功能。简单来说，它就是Python与JSON世界沟通的桥梁。

在Python中，处理JSON数据主要是围绕着

json

模块的几个核心函数展开的。当我们从网络API获取到JSON字符串，或者从文件读取到JSON内容时，通常会使用

json.loads()

或

json.load()

将其解析成Python字典或列表。反之，如果需要将Python数据结构（如字典、列表）发送给API或写入文件，则会用到

json.dumps()

或

json.dump()

将其序列化成JSON格式的字符串。这个过程其实相当直观，就像我们把一份结构化的报告翻译成另一种语言，再从那种语言翻译回来一样，核心是保持信息的完整性和结构的一致性。

import json

# 示例1: 从JSON字符串解析到Python对象 (反序列化)
json_string = '{"name": "张三", "age": 30, "isStudent": false, "courses": ["Python", "Data Science"]}'
python_data = json.loads(json_string)
print(f"解析后的Python数据类型: {type(python_data)}")
print(f"解析后的Python数据: {python_data}")
print(f"访问姓名: {python_data['name']}")

# 示例2: 从Python对象生成JSON字符串 (序列化)
python_dict = {
    "product": "Laptop",
    "price": 1200.50,
    "features": ["SSD", "16GB RAM"],
    "available": True
}
json_output = json.dumps(python_dict, indent=4, ensure_ascii=False) # indent用于美化输出，ensure_ascii=False支持中文
print(f"\n序列化后的JSON字符串:\n{json_output}")

# 示例3: 处理JSON文件 (读写)
data_to_write = {
    "city": "Beijing",
    "population": 21000000,
    "landmarks": ["Great Wall", "Forbidden City"]
}
file_path = "data.json"

# 写入JSON文件
with open(file_path, 'w', encoding='utf-8') as f:
    json.dump(data_to_write, f, indent=4, ensure_ascii=False)
print(f"\n数据已写入 {file_path}")

# 从JSON文件读取
with open(file_path, 'r', encoding='utf-8') as f:
    read_data = json.load(f)
print(f"从文件读取的数据: {read_data}")

# Python数据类型与JSON类型映射概览：
# Python          | JSON
# ----------------|----------------
# dict            | object
# list, tuple     | array
# str             | string
# int, float      | number
# True            | true
# False           | false
# None            | null

在实际操作中，

json.dumps()

的

indent

参数非常实用，它能让输出的JSON字符串带上缩进，极大提升可读性，尤其是在调试或人工查看JSON数据时。而

ensure_ascii=False

则确保了非ASCII字符（比如中文）能以原样输出，而不是被转义成

\uXXXX

的形式，这对于国际化应用来说是个小细节但很关键。

Python处理大型JSON文件时如何优化性能和内存占用？

处理大型JSON文件，比如几百MB甚至几个GB的文件，直接使用

json.load()

一次性加载到内存中，往往会导致内存溢出（MemoryError），或者让程序运行得异常缓慢。这就像你想一口气喝完一桶水，不现实也不舒服。我的经验是，这时候就需要考虑“流式处理”或者“按需解析”的策略了。

立即学习“Python免费学习笔记（深入）”；

一种常见的优化方式是，如果JSON文件是一个包含大量独立JSON对象的列表，我们可以尝试逐行读取并解析。但这有个前提，就是文件中的每个JSON对象必须是独立且合法的，并且通常以换行符分隔。然而，更通用的解决方案是利用第三方库，比如

ijson

。

ijson

库允许你像迭代器一样遍历大型JSON结构，它不会一次性将整个JSON加载到内存，而是根据你的请求逐步解析，这极大地降低了内存消耗。

# 假设有一个名为 large_data.json 的大型文件，内容结构类似：
# [
#   {"id": 1, "value": "abc"},
#   {"id": 2, "value": "def"},
#   ...
# ]

# 伪代码示例，需要安装 ijson: pip install ijson
# import ijson
#
# try:
#     with open('large_data.json', 'rb') as f: # 注意，ijson通常需要以二进制模式打开文件
#         # items(''), 'item'表示解析根数组下的每个元素
#         # 如果根是一个对象，可以指定路径，如 items('data.items')
#         for record in ijson.items(f, 'item'):
#             # 在这里处理每个 record，比如写入数据库、聚合数据等
#             print(f"处理记录: {record['id']}")
#             # 模拟一些处理
#             if record['id'] > 5:
#                 break # 提前退出，节省资源
# except FileNotFoundError:
#     print("large_data.json 文件未找到。")
# except Exception as e:
#     print(f"处理 large_data.json 时发生错误: {e}")

# 另一种思路是，如果JSON结构允许，可以尝试分块读取文件内容，
# 但这通常需要对JSON结构有深入了解，确保分块不会截断有效的JSON对象。
# 比如，如果文件是多个独立JSON对象用换行符分隔，则可以逐行读取。
# with open('multiple_objects.json', 'r', encoding='utf-8') as f:
#     for line in f:
#         if line.strip(): # 确保不是空行
#             try:
#                 obj = json.loads(line)
#                 print(f"处理独立对象: {obj}")
#             except json.JSONDecodeError as e:
#                 print(f"解析行失败: {line.strip()} - {e}")

ijson

的强大之处在于它能让你指定解析路径，比如你只关心JSON中某个深层嵌套的列表或对象，

ijson

就能直接帮你定位到那里，而无需解析整个文件。这在处理超大型、结构复杂的JSON时，能显著提高效率和降低内存占用。当然，选择哪种方法，最终还是取决于你的JSON数据结构和具体的处理需求。

Nanonets

基于AI的自学习OCR文档处理，自动捕获文档数据

下载

在Python中解析JSON数据时，如何处理常见的错误和异常？

解析JSON数据并非总是一帆风顺，尤其是在从外部源获取数据时，可能会遇到格式不规范、数据缺失或类型不匹配等问题。这时候，Python的错误处理机制就显得尤为重要了。最常见的错误是

json.JSONDecodeError

，它发生在尝试解析一个并非有效JSON格式的字符串时。这就像你给翻译器一本乱码的书，它自然无法理解。

import json

# 错误示例1: 无效的JSON格式
invalid_json_string = '{"name": "Alice", "age": 25,' # 缺少闭合括号
try:
    data = json.loads(invalid_json_string)
    print(data)
except json.JSONDecodeError as e:
    print(f"JSON解析错误: {e}")
    print(f"错误发生在位置: {e.pos}, 行: {e.lineno}, 列: {e.colno}")

# 错误示例2: 数据缺失 (KeyError)
valid_json_string = '{"user_id": 123, "username": "bob"}'
try:
    user_data = json.loads(valid_json_string)
    # 尝试访问一个不存在的键
    email = user_data['email']
    print(f"用户邮箱: {email}")
except KeyError as e:
    print(f"数据访问错误: 键 '{e}' 不存在。")
    # 可以提供默认值或记录日志
    email = "unknown@example.com"
    print(f"使用默认邮箱: {email}")

# 错误示例3: 数据类型不匹配或预期值不符
data_with_wrong_type = '{"id": "abc", "value": "123"}'
try:
    item = json.loads(data_with_wrong_type)
    # 假设我们期望 id 是整数
    item_id = int(item['id'])
    print(f"处理后的ID: {item_id}")
except ValueError as e:
    print(f"数据类型转换错误: {e}")
except TypeError as e:
    print(f"数据类型错误: {e}")

处理这些错误的关键在于使用

try-except

块。对于

json.JSONDecodeError

，你可以捕获它，然后根据错误信息判断是数据源的问题还是传输过程中的问题。对于

KeyError

，这意味着你尝试访问的键在JSON数据中不存在，这通常发生在数据结构不一致或API返回的数据不符合预期时。我的做法是，对于这种可预见的缺失，通常会提供一个默认值，或者检查键是否存在（

if 'key' in dict:

），避免程序崩溃。而像

ValueError

或

TypeError

，则通常是在你尝试将解析出的数据转换为特定类型（如

int()

、

float()

）时发生，这表明原始数据类型与你的预期不符。总之，健壮的JSON处理代码，离不开细致的错误预判和处理。

Python如何将自定义对象序列化为JSON，以及反序列化回自定义对象？

将Python的内置类型（如字典、列表、字符串、数字等）序列化为JSON是

json

模块的拿手好戏。但当我们有自定义的类实例时，比如一个

User

对象，直接

json.dumps(user_object)

通常会报错

TypeError: Object of type User is not JSON serializable

。这是因为

json

模块不知道如何将你的自定义对象转换为JSON可识别的类型。不过，Python提供了灵活的机制来解决这个问题。

核心思路是告诉

json

模块如何“看懂”你的自定义对象。序列化时，你可以提供一个

default

函数给

json.dumps()

，这个函数会在

json

模块遇到它不认识的对象时被调用。在这个函数里，你可以定义如何将你的自定义对象转换为一个JSON友好的字典或列表。反序列化时，

json.loads()

提供了一个

object_hook

参数，它是一个函数，会在

json

模块解析出一个JSON对象（即Python字典）后被调用。你可以在这个函数里检查字典内容，并将其转换回你的自定义对象实例。

import json

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

    def __repr__(self):
        return f"User(name='{self.name}', age={self.age}, email='{self.email}')"

# 序列化自定义对象
def user_encoder(obj):
    if isinstance(obj, User):
        return {
            '__type__': 'User', # 标记这是一个User对象，方便反序列化
            'name': obj.name,
            'age': obj.age,
            'email': obj.email
        }
    raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")

# 创建一个User实例
user1 = User("李华", 28, "lihua@example.com")

# 使用自定义编码器序列化
json_user = json.dumps(user1, default=user_encoder, indent=4, ensure_ascii=False)
print(f"序列化后的User对象:\n{json_user}")

# 反序列化回自定义对象
def user_decoder(dct):
    if '__type__' in dct and dct['__type__'] == 'User':
        return User(dct['name'], dct['age'], dct['email'])
    return dct # 如果不是User对象，原样返回字典

# 使用自定义解码器反序列化
decoded_user = json.loads(json_user, object_hook=user_decoder)
print(f"\n反序列化后的对象: {decoded_user}")
print(f"反序列化后的对象类型: {type(decoded_user)}")

# 另一种更面向对象的方法是继承json.JSONEncoder和json.JSONDecoder
class UserEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, User):
            return {
                '__type__': 'User',
                'name': obj.name,
                'age': obj.age,
                'email': obj.email
            }
        return json.JSONEncoder.default(self, obj) # 让基类处理其他类型

# 使用自定义Encoder
json_user_with_class = UserEncoder(indent=4, ensure_ascii=False).encode(user1)
print(f"\n使用自定义Encoder序列化:\n{json_user_with_class}")

我个人更倾向于使用继承