深入解析：如何在 Python 中优雅地处理复杂 JSON 的序列化与反序列化

2026-02-07 03:55:31 0条评论 2次阅读 0人点赞

在日常的 Python 开发工作中，你肯定没少和 JSON 打交道。作为数据交换领域无可争议的“通用语言”，JSON 凭借其轻量级和跨平台的特性，几乎无处不在——从后端 API 的响应体，到微服务之间的消息队列，再到复杂的配置文件，它都在默默承担着数据载体的重任。

然而，处理简单的键值对（比如 INLINECODE60aa554b）通常轻而易举，但当我们面对现实世界中层层嵌套、结构复杂的业务数据时，事情就变得棘手起来了。你是否曾遇到过 INLINECODE0a5b3eea 这样的报错？或者在尝试将一个 JSON 字符串还原回带有方法的 Python 对象时感到束手无策？

别担心，在这篇文章中，我们将作为并肩作战的开发者，深入探索 Python 中 json 模块的底层机制。我们将从最基础的概念入手，逐步攻克嵌套对象、自定义类的序列化难题，并最终掌握一套能够优雅处理任意复杂数据结构的“组合拳”。让我们开始吧。

什么是复杂的 JSON 结构？

在正式动手之前，我们先明确一下什么是“复杂”的 JSON。通常，我们将包含嵌套对象、数组列表以及两者混合组合的结构称为复杂 JSON。理解这些结构是编写高效解析逻辑的第一步。

让我们通过几个直观的例子来认识它们：

1. 嵌套对象

这是最基础的复杂形式，即“对象套对象”。

{
  "student": {
    "name": "John",
    "age": 20,
    "details": {
      "grade": "A",
      "school": "High School"
    }
  }
}

2. 包含数组的数据

一个对象中包含了列表数据，这在处理批量信息时非常常见。

{
  "fruits": ["apple", "banana", "mango"],
  "count": 3
}

3. 对象数组

这是一个列表，但列表中的每一项都是一个完整的对象。例如，一个包含多名用户信息的数组。

[
  { "id": 1, "name": "James", "role": "Admin" },
  { "id": 2, "name": "Jennie", "role": "User" }
]

4. 混合型嵌套

这是现实场景中最常见的形态——对象、列表、字典相互交织。例如，一个班级包含多个学生，每个学生又有各自的成绩列表。

{
  "class_name": "Science 101",
  "students": [
    { 
      "name": "Sam", 
      "marks": [85, 90, 88] 
    },
    { 
      "name": "Lily", 
      "marks": [92, 87, 91] 
    }
  ]
}

核心概念：序列化与反序列化

为了在 Python 和这些 JSON 格式之间自由切换，我们需要掌握两个核心动作：

序列化：这是将 Python 对象（如类实例、字典、列表）转换成 JSON 格式字符串的过程。这样我们就可以将其保存到文件中或通过网络发送。我们主要使用 json.dumps() 方法来实现。
反序列化：这是序列化的逆过程，即将 JSON 格式的字符串解析并转换回 Python 的对象（通常是字典或列表）。我们主要使用 json.loads() 方法。

第一阶段：处理简单的 Python 对象

当你的数据结构仅包含 Python 的基本数据类型（字符串、数字、布尔值、None、列表、字典）时，一切都非常简单。内置的 json 模块完全能胜任。

场景： 我们有一个简单的用户类，只包含姓名。

import json

class User:
    """一个简单的用户类"""
    def __init__(self, first_name: str, last_name: str):
        self.first_name = first_name
        self.last_name = last_name

    def __str__(self):
        return f"User: {self.first_name} {self.last_name}"

# 1. 创建 Python 对象
user = User(first_name="Jake", last_name="Doyle")

# 2. 序列化：Python 对象 -> JSON 字符串
# 这里的技巧是使用 __dict__ 属性将对象转换为字典
json_str = json.dumps(user.__dict__)
print(f"序列化结果: {json_str}")

# 3. 反序列化：JSON 字符串 -> Python 字典
data_dict = json.loads(json_str)

# 4. 将字典重新实例化为对象
new_user = User(**data_dict) 
print(f"反序列化对象: {new_user}")

代码解析：

在这个例子中，INLINECODE4d74ffe6 是关键。它将对象的属性（INLINECODE4e486783, INLINECODEd2164d4f）转换成了一个标准的 Python 字典 INLINECODEf5ba5399。INLINECODEb900d75a 完美支持字典，因此序列化顺理成章。还原时，我们利用 INLINECODEdf9d2172 解包语法将字典键值对作为参数传递给类的构造函数。

第二阶段：挑战复杂的嵌套对象

问题总是出现在我们想要做更复杂的事情时。如果我们有一个 INLINECODEb3582c25 类，它包含了一个 INLINECODEf089b3d7 对象的列表，直接使用 __dict__ 技巧就会失效。

让我们试着运行下面这段代码，看看会发生什么：

import json

class Student:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

class Team:
    def __init__(self, students: list):
        self.students = students

student1 = Student("Alice", 20)
student2 = Student("Bob", 22)
team = Team([student1, student2])

# 尝试直接序列化
try:
    # 注意：这里即使传了 __dict__，内部的 Student 对象依然无法被序列化
    json_data = json.dumps(team.__dict__, indent=2)
    print(json_data)
except TypeError as e:
    print(f"错误捕获: {e}")

运行结果：

你肯定会看到报错：TypeError: Object of type Student is not JSON serializable。

为什么会这样？

因为 INLINECODEf2c99b38 默认只知道如何处理基本类型（str, int, dict, list等）。当它遇到 INLINECODE948c0405 类的实例时，它完全不知道这个对象是什么，也不知道该如何把它转换成文本。它试图递归查找，但在 Student 这里卡住了。

解决方案 1：使用 `default` 参数进行自定义序列化

为了解决这个问题，我们需要给 INLINECODEa219d469 提供一个“说明书”，告诉它在遇到不认识的对象时该怎么办。我们可以通过 INLINECODE597e26a2 参数传递一个函数（通常是 lambda 函数）。

这个函数的逻辑是：如果遇到未知对象，就强制调用它的 __dict__ 属性，将其转为字典。

import json

class Student:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

class Team:
    def __init__(self, students: list):
        self.students = students

# 准备数据
student1 = Student("Alice", 20)
student2 = Student("Bob", 22)
team = Team([student1, student2])

# 优化后的序列化方法
# 使用 lambda 函数作为 fallback：如果对象不能序列化，就调用其 __dict__
json_data = json.dumps(team, default=lambda o: o.__dict__, indent=2)
print("--- 序列化成功 ---")
print(json_data)

这段代码的神奇之处：

INLINECODE893ff771 会遍历 INLINECODE47d0305e 对象。当它处理 INLINECODEcba91e56 列表时，遇到了 INLINECODE3156f032 实例。由于默认编码器不认识 INLINECODE158d33fa，它触发了 INLINECODE0bc430d7 参数指向的 lambda 函数。INLINECODEac68e4b9 随即被执行，将 INLINECODE8a976540 对象变成了字典，使得序列化能够继续进行。

解决方案 2：进阶——完整的序列化与反序列化（编码器/解码器）

虽然 INLINECODE1c4198b5 参数解决了序列化的问题，但如果我们想要将 JSON 字符串完美还原回原来的 INLINECODEccb7b5b2 和 Student 对象（不仅仅是字典），我们需要编写自定义的编码器和解码器。这才是企业级开发中最稳健的做法。

让我们来重构代码，使其更加专业和可复用。

#### 步骤 1：自定义编码器

我们需要继承 INLINECODE4d912bba 并重写 INLINECODE57d2da97 方法。

import json

class Student:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

class Team:
    def __init__(self, name: str, students: list):
        self.name = name
        self.students = students

class ComplexObjectEncoder(json.JSONEncoder):
    """自定义编码器，用于处理复杂对象的序列化"""
    def default(self, obj):
        # 如果对象有 __dict__ 属性（即我们的自定义类），将其转为字典
        if hasattr(obj, ‘__dict__‘):
            return obj.__dict__
        # 否则，调用父类的默认处理（通常会抛出 TypeError）
        return super().default(obj)

# --- 测试序列化 ---
s1 = Student("Geek", 25)
s2 = Student("Nerd", 26)
team = Team("Coding Squad", [s1, s2])

# 使用 cls 参数指定我们的自定义编码器
json_str = json.dumps(team, cls=ComplexObjectEncoder, indent=2)
print("序列化后的 JSON:")
print(json_str)

#### 步骤 2：自定义解码器

反序列化稍微复杂一点，因为我们需要知道某个字典原本对应的是哪个类。我们可以利用 Python 的 __name__ 或者通过字典中的特定字段来识别。

为了让代码更通用，我们可以给类增加一个标识字段，或者在解码时手动指定映射关系。下面的例子展示了一种通用的“钩子”方法。

import json

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

class Team:
    def __init__(self, name, students):
        self.name = name
        self.students = students

def custom_object_hook(dct):
    """自定义解码钩子，用于将字典还原为对象"""
    # 这里我们通过简单的特征检测来判断类型
    # 注意：在实际生产中，通常会在 JSON 中包含 ‘__type__‘ 字段来明确指示类型
    
    if ‘name‘ in dct and ‘students‘ in dct:
        # 看起来像是 Team 对象
        return Team(dct[‘name‘], dct[‘students‘])
    
    if ‘name‘ in dct and ‘age‘ in dct:
        # 看起来像是 Student 对象
        return Student(dct[‘name‘], dct[‘age‘])
        
    # 如果都不匹配，返回普通字典
    return dct

# 模拟一个从文件读取的 JSON 字符串
mock_json = ‘‘‘
{
    "name": "Super Coders",
    "students": [
        {"name": "Alice", "age": 30},
        {"name": "Bob", "age": 35}
    ]
}
‘‘‘

# 使用 object_hook 参数进行反序列化
data = json.loads(mock_json, object_hook=custom_object_hook)

print("
反序列化验证:")
print(f"对象类型: {type(data)}")
print(f"对象名称: {data.name}")
print(f"第一个学生类型: {type(data.students[0])}")
print(f"第一个学生姓名: {data.students[0].name}")

最佳实践与常见陷阱

在处理复杂的 JSON 数据时，除了掌握基本的 API，了解一些“坑”和“技巧”能让你少走很多弯路。

1. 处理非 ASCII 字符

如果你处理的数据包含中文或特殊符号，可能会发现 JSON 串中充满了 \uXXXX 这样的转义字符。虽然这是合法的，但可读性极差。

解决方案： 在 INLINECODE4e0ca1a6 中添加 INLINECODEb5bc11b8。

    data = {‘name‘: ‘张三‘}
    # 默认输出: {"name": "\u5f20\u4e09"}
    # 优化输出: {"name": "张三"}
    print(json.dumps(data, ensure_ascii=False))

2. 数据类型不匹配

JSON 没有日期/时间类型，也没有 set 类型。

日期：通常序列化为字符串 (ISO 8601 格式) 或时间戳。反序列化时，你需要手动将字符串转回 datetime 对象。
Set：INLINECODEfcab4462 会直接报错。你需要先将 INLINECODE779d19a0 转换为 list。

3. 安全性警告：__dict__ 的局限性

虽然我们在示例中大量使用了 INLINECODEb1b9b975，但在生产环境中要注意，某些对象（比如文件句柄、数据库连接）不应该被序列化。此外，使用 INLINECODEdd73c69e 解包来还原对象时，如果 JSON 中包含了类构造函数中不存在的字段，程序会崩溃。务必做好异常捕获。

总结

在这篇文章中，我们从最基础的定义出发，一步步探讨了如何处理 Python 中日益复杂的 JSON 数据结构。

对于简单对象，利用 INLINECODE54caafee 和 INLINECODE969de935 的解包特性就能轻松搞定。
对于嵌套对象，我们可以通过 INLINECODE447ee2b0 参数或自定义 INLINECODE3dfe255d 来告诉 Python 如何处理非标准类型。
为了完美的双向转换，编写配套的 object_hook 函数是关键，它能让你直接获得带有完整属性和方法的对象，而不是冷冰冰的字典。

掌握这些技能后，无论面对多么复杂的 Web API 响应或是配置文件结构，你都能游刃有余地进行解析和处理。希望这些技巧能应用到你下一个项目的开发中！

投稿给我们	如何建站？
vps是什么？	如何安装宝塔？
如何通过博客赚钱？	便宜wordpress托管方案
免费wordpress主题	这些都是免费方案

豆丁博客

深入解析：如何在 Python 中优雅地处理复杂 JSON 的序列化与反序列化

什么是复杂的 JSON 结构？

核心概念：序列化与反序列化

第一阶段：处理简单的 Python 对象

第二阶段：挑战复杂的嵌套对象

解决方案 1：使用 `default` 参数进行自定义序列化

解决方案 2：进阶——完整的序列化与反序列化（编码器/解码器）

最佳实践与常见陷阱

总结

相关文章美国1G带宽/1T流量高速vps $17.99/年

深入解析：如何在 Python 中优雅地处理复杂 JSON 的序列化与反序列化

什么是复杂的 JSON 结构？

核心概念：序列化与反序列化

第一阶段：处理简单的 Python 对象

第二阶段：挑战复杂的嵌套对象

解决方案 1：使用 default 参数进行自定义序列化

解决方案 2：进阶——完整的序列化与反序列化（编码器/解码器）

最佳实践与常见陷阱

总结

相关文章美国1G带宽/1T流量高速vps $17.99/年

解决方案 1：使用 `default` 参数进行自定义序列化