Python 实战指南：如何将 JSON 数据高效转换为 XML 格式

在当今的软件开发领域，数据交换格式的转换依然是我们经常面临的基础任务。尽管微服务和 API 优先的设计日益普及，但在 2026 年，我们依然会经常遇到这种“代沟”场景：你的现代化云原生应用返回的是轻量级的 JSON 数据，但你的银行合作伙伴或企业级遗留系统却要求必须使用严谨的 XML 格式。或者，你可能正在维护一个核心 ERP 系统，它只能“理解”基于树状结构的 XML 文档。作为一名 Python 开发者，我们需要掌握在这些格式之间灵活转换的技能，这不仅仅是语法问题，更是系统架构集成能力的一部分。

在这篇文章中，我们将深入探讨如何使用 Python 强大的标准库以及现代工具链，将 JSON 数据转换为结构良好的 XML 文档。我们不仅要实现基础的转换功能，还会深入分析代码背后的逻辑，比较这两种格式的差异，并分享在实际开发中处理复杂数据结构的最佳实践。

JSON 与 XML：数据格式的双璧

在开始编写代码之前，让我们先快速了解一下我们将要处理的这两种“主角”。

什么是 JSON？

JavaScript 对象表示法（JSON）是一种轻量级的数据交换格式。它基于 JavaScript 语言的一个子集，但是完全独立于语言。JSON 的核心优势在于它的简洁性和易读性。它使用键值对来存储数据，结构清晰，非常适合现代 Web 应用程序的前后端交互。

JSON 文件的一些显著特点包括：

• 数据类型：支持字符串、数字、布尔值、数组、对象和 null。
• 语法：数据由逗号分隔，键值对由冒号分隔，对象由花括号 INLINECODEb2b9a41b 包裹，数组由方括号 INLINECODE0aa048f6 包裹。
• 可读性：虽然是机器可解析的，但也非常适合人类阅读和编写。

什么是 XML？

可扩展标记语言（XML）是一种元标记语言，旨在存储和传输数据。与 HTML 不同，XML 没有预定义的标签，它允许我们根据需求自定义标签结构。XML 的设计宗旨是强调数据的结构化和独立性。

XML 的主要特征包括：

• 结构化：使用树形结构来表示数据，非常适合复杂的嵌套数据。
• 元数据支持：支持属性和命名空间，能携带更丰富的描述信息。
• 平台无关性：纯文本格式，几乎可以在任何平台上读取和处理。

深入对比：JSON 与 XML 的差异

虽然它们都服务于数据传输的目的，但在具体的实现细节上各有千秋。了解这些差异有助于我们在转换时做出更好的决策。

JSON

:—

具有明确的类型（字符串, 数字, 布尔等）

像对象属性一样直接访问，极其方便

不包含标签，通常体积更小，传输更快

原生支持，JSON.parse 即可使用

不支持注释，仅支持文本和数字

结构相对固定

如果使用 eval 解析可能不安全（尽管现在很少这样做）

在 Python 3 中处理 JSON 到 XML 的转换

Python 提供了非常强大的标准库来处理这两种格式。为了将 JSON 转换为 XML，我们将主要使用两个模块：

• json 模块：用于读取和解析 JSON 数据。
• xml.etree.ElementTree 模块：用于构建 XML 树结构并将其写入文件。

#### 核心步骤解析

让我们将整个转换过程分解为清晰的步骤。为了让你更容易理解，我们将从一个简单的例子开始，然后逐步深入到更复杂的场景。

准备工作：导入必要的模块

首先，我们需要导入 Python 的标准库模块。为了代码的简洁，我们通常会使用别名。

# 用于读取 JSON 文件
import json as JS

# 用于构建和写入 XML 文件
import xml.etree.ElementTree as ET

#### 示例 1：基础的简单转换

假设我们有一个非常简单的 JSON 文件 data.json，内容如下：

{
  "user": {
    "name": "Alice",
    "id": 1001,
    "is_active": true
  }
}

我们的目标是将这个 JSON 对象转换成如下的 XML 结构：

    Alice
    1001
    true

编写转换代码：

import json
import xml.etree.ElementTree as ET

# 1. 读取 JSON 文件
try:
    with open(‘data.json‘, ‘r‘, encoding=‘utf-8‘) as json_file:
        data = json.load(json_file)
except FileNotFoundError:
    print("错误：找不到 JSON 文件")
    exit()

# 2. 构建 XML 根元素
# JSON 的根键是 "user"，我们将它作为 XML 的根标签
root_key = list(data.keys())[0]
root = ET.Element(root_key)

# 3. 遍历 JSON 数据并构建子元素
child_data = data[root_key]
for key, value in child_data.items():
    # XML 元素不支持非字符串数据，我们需要将所有值转换为字符串
    child = ET.SubElement(root, key)
    child.text = str(value)

# 4. 生成 XML 树并美化输出
# 为了让输出更易读，我们可以进行缩进处理（Python 3.9+ 支持）
ET.indent(root, space="\t")

# 5. 写入文件
tree = ET.ElementTree(root)
tree.write(‘output.xml‘, encoding=‘utf-8‘, xml_declaration=True)

print("转换成功！文件已保存为 output.xml")

#### 示例 2：处理复杂数据结构（列表与嵌套）

现实世界的数据往往比上面的例子复杂得多。让我们来看一个更具挑战性的例子。假设我们有一个包含测验题目的 JSON 文件 quiz.json。

JSON 文件内容 (quiz.json)：

{
  "quiz": {
    "maths": {
      "q1": {
        "question": "5 + 7 = ?",
        "options": ["10", "11", "12", "13"],
        "answer": "12"
      }
    }
  }
}

在这个例子中，我们遇到了一个 列表 (options)。XML 本身没有“数组”的概念，列表通常通过多个同名标签来表示。这是转换过程中的一个难点。

完整的转换脚本：

import json as JS
import xml.etree.ElementTree as ET

def json_to_xml(xml_element, json_data):
    """
    递归函数，将 JSON 数据构建到 XML 元素中
    """
    # 如果是字典，创建子元素
    if isinstance(json_data, dict):
        for key, value in json_data.items():
            # 如果 key 是特殊字符，需要处理，这里假设 key 合法
            child = ET.SubElement(xml_element, key)
            json_to_xml(child, value)
    # 如果是列表，创建多个同名子元素
    elif isinstance(json_data, list):
        for item in json_data:
            # 对于列表项，我们需要一个父标签（通常是复数形式或 ‘item‘）
            # 这里我们在调用处处理，或者约定列表项的标签名
            # 为了演示，假设 list 的元素已经是特定类型，直接创建 ‘item‘
            item_element = ET.SubElement(xml_element, "item")
            json_to_xml(item_element, item)
    # 如果是基本类型，设置文本内容
    else:
        xml_element.text = str(json_data)

# 主程序
with open("quiz.json", "r", encoding=‘utf-8‘) as json_file:
    data = JS.load(json_file)

# 获取根节点数据（这里手动获取 ‘quiz‘）
root_data = data.get(‘quiz‘, {})
root = ET.Element("root") # 创建一个虚拟的总根节点

json_to_xml(root, root_data)

# 此时 root 的结构是 ...
# 我们通常直接取 quiz 作为实际根，或者直接处理
# 修正：直接构建根元素
root = ET.Element("quiz")
maths_sub = ET.SubElement(root, "maths")

# 手动映射以保持代码清晰展示具体逻辑
q1_data = data[‘quiz‘][‘maths‘][‘q1‘]
q1_element = ET.SubElement(maths_sub, "q1")

# 处理 question
question_el = ET.SubElement(q1_element, "question")
question_el.text = q1_data["question"]

# 处理 options (列表)
# 在 XML 中，我们通常这样表示：
# 
#   10
#   11
# 
options_el = ET.SubElement(q1_element, "options")
for opt in q1_data["options"]:
    ET.SubElement(options_el, "option").text = opt

# 处理 answer
answer_el = ET.SubElement(q1_element, "answer")
answer_el.text = q1_data["answer"]

# 写入文件
ET.indent(root, space="\t")
tree = ET.ElementTree(root)
tree.write("quiz_converted.xml", encoding="utf-8", xml_declaration=True)

print("复杂的 Quiz JSON 已成功转换为 XML！")

2026 年开发视角：现代工程化实践

作为 2026 年的开发者，我们不仅要关注代码逻辑的正确性，还要思考如何利用现代化的工具链和理念来提升开发效率和代码质量。在我们最近的几个企业级项目中，我们已经开始引入 Vibe Coding（氛围编程） 和 AI 辅助工作流 来处理这类传统任务。

#### 1. 利用 Cursor 和 Copilot 辅助转换逻辑

当我们面对极其复杂的、包含多层嵌套和特殊属性的 JSON 到 XML 转换需求时，手写递归函数既枯燥又容易出错。现在，我们更倾向于使用像 Cursor 或 Windsurf 这样的 AI 原生 IDE。

实践技巧：

我们可以直接在 IDE 中编写一段注释，描述我们的 XML 目标结构，然后让 AI 帮我们生成转换函数。例如，我们可能会输入：“创建一个递归函数，将字典转换为 XML，遇到列表时用 包裹，并将字典的特定键（如 ‘id‘）转换为 XML 属性而非子节点。”

这种工作流不仅节省了时间，更重要的是，它让我们能够专注于业务逻辑的映射，而陷入语法细节的泥潭。我们可以把这看作是“结对编程”，AI 负责生成样板代码，而我们负责审查和优化。

#### 2. 生产级代码：健壮性与容错处理

上面的示例代码非常适合学习，但在生产环境中，我们需要考虑到边界情况。在实际项目中，我们曾遇到过 JSON 数据中包含非法 XML 字符（如 INLINECODE71b72313, INLINECODEbf6839cf）或者键名包含空格的情况，这会导致生成的 XML 文件损坏或无法解析。

让我们来看一个更加健壮的、生产级的实现思路。

生产级优化示例：

import json
import xml.etree.ElementTree as ET
import re

def sanitize_tag_name(name):
    """
    清理键名以确保它是一个合法的 XML 标签名。
    如果键名包含非法字符，我们可以选择替换或者作为属性（如果是根节点）。
    这里演示简单的替换策略。
    """
    # XML 标签名不能以数字开头，不能包含空格或特殊字符
    clean_name = re.sub(r"[^a-zA-Z0-9_-]", "_", name)
    # 如果以数字开头，前缀下划线
    if clean_name[0].isdigit():
        clean_name = "_" + clean_name
    return clean_name

def build_xml_element(parent, key, value):
    """
    递归构建 XML 树的增强版。
    """
    # 处理键名合法性问题
    tag_name = sanitize_tag_name(key)
    
    # 情况 1: 字典 -> 创建子节点并递归
    if isinstance(value, dict):
        child = ET.SubElement(parent, tag_name)
        for k, v in value.items():
            build_xml_element(child, k, v)
            
    # 情况 2: 列表 -> 创建包裹节点（根据约定）
    elif isinstance(value, list):
        # 我们可以约定：列表生成 ... 的结构
        list_wrapper = ET.SubElement(parent, tag_name)
        for item in value:
            # 这里假设列表项主要是字典或基本类型
            # 如果是字典，我们使用 ‘item‘ 作为标签，或者尝试取其中的通用键
            if isinstance(item, dict):
                item_node = ET.SubElement(list_wrapper, "item")
                for k, v in item.items():
                    build_xml_element(item_node, k, v)
            else:
                item_node = ET.SubElement(list_wrapper, "item")
                item_node.text = str(item)
                
    # 情况 3: 基本类型 -> 设置文本
    else:
        # 检查 value 是否为 None
        text_value = "" if value is None else str(value)
        # 处理 XML 中的特殊字符转义（ElementTree 默认会处理 text，但显式处理更安全）
        child = ET.SubElement(parent, tag_name)
        child.text = text_value

# 使用示例
# 假设我们从 API 获取了复杂的 JSON 数据
api_response = """
{
    "order_123": {
        "customer details": {
            "name": "John Doe & Sons",
            "priority": 1
        },
        "items": [
            {"product": "Apple", "qty": 10},
            {"product": "Banana", "qty": 20}
        ],
        "is_paid": true
    }
}
"""

data = json.loads(api_response)
root = ET.Element("root")

for key, value in data.items():
    build_xml_element(root, key, value)

# 美化输出
ET.indent(root)
print(ET.tostring(root, encoding=‘unicode‘))

关键改进点：

• 标签名清洗 (sanitize_tag_name)：这是我们在生产环境中踩过的坑。JSON 的键非常灵活，但 XML 的标签名非常严格。如果不处理，转换程序会直接崩溃。

n2. 列表包裹策略：在 XML 中表示列表一直是个痛点。我们在代码中约定了使用 ... 的结构，这比直接平铺更易于后续的 XSD 验证和解析。

#### 3. 性能优化与流式处理

当我们在处理动辄几百 MB 甚至 GB 级别的日志文件或数据转储时，直接使用 json.load() 将整个文件载入内存是不可取的（OOM 错误）。

优化策略：

在 2026 年，我们推荐使用 INLINECODE4339669b 库进行流式解析。INLINECODEac120b70 允许我们像遍历文件指针一样遍历 JSON 结构，从而在内存中只保留当前处理的数据块。

使用 ijson 的思路：

import ijson
import xml.etree.ElementTree as ET

# 伪代码示例：流式处理大 JSON 文件
with open(‘huge_data.json‘, ‘rb‘) as f:
    # 假设 JSON 是一个大的对象列表
    # prefix 指向我们要遍历的路径
    for prefix, event, value in ijson.parse(f):
        if prefix.endswith(‘item‘): 
            # 当解析到一个 item 时，处理它并立即写入 XML 文件
            # 这里可以配合构建局部 XML 树并追加到输出文件中
            pass 

通过这种方式，无论 JSON 文件有多大，我们的内存占用始终保持在低位，这对于构建高可用的数据处理管道至关重要。

总结

通过这篇文章，我们不仅学习了如何使用 Python 的 INLINECODEa88278ee 和 INLINECODE2d6a6d09 模块将 JSON 转换为 XML，更重要的是，我们了解了这两种格式在结构上的根本差异。从简单的键值对到复杂的嵌套列表，掌握这些转换技巧能让你在处理不同系统间的数据集成时更加游刃有余。

我们鼓励你尝试运行上面的代码示例，并修改 JSON 数据来观察生成的 XML 变化。如果你在日常开发中频繁需要进行此类转换，甚至可以考虑将这些逻辑封装成一个通用的工具函数或类，以提高代码的复用性。希望这篇文章能为你的技术工具箱增添一件有力的武器！