用 Python 处理 JSON/XML 数据：高效解析与格式转换

8次阅读

共计 8982 个字符，预计需要花费 23 分钟才能阅读完成。

在当今数字化的世界里，数据是驱动一切的燃料。无论是网络服务之间的通信、应用程序的配置，还是数据的持久化存储，我们都离不开高效的数据交换格式。其中，JSON (JavaScript Object Notation) 和 XML (Extensible Markup Language) 无疑是两大主流。它们以结构化、可读性强的方式承载着海量信息。

对于开发者而言，如何有效地解析、处理并转换这些数据，是日常工作中不可或缺的技能。Python，凭借其简洁的语法、强大的生态系统和丰富的标准库，成为了处理 JSON 和 XML 数据的理想工具。本文将深入探讨如何使用 Python 高效地解析 JSON 和 XML 数据，实现灵活的格式转换，并分享一些最佳实践，助你成为数据处理的高手。

JSON 是一种轻量级的数据交换格式，易于人阅读和编写，也易于机器解析和生成。它基于 JavaScript 编程语言的一个子集，但独立于语言。JSON 的数据结构非常简单，主要由两种结构组成：

“名称 / 值”对的集合 (collection of name/value pairs)：在 Python 中，这对应于字典 (dictionary)。
值的有序列表 (ordered list of values)：在 Python 中，这对应于列表 (list)。

Python 的 `json` 模块

Python 标准库内置的 json 模块提供了所有处理 JSON 数据所需的功能。它能将 JSON 字符串或文件解析为 Python 对象（反序列化），也能将 Python 对象序列化为 JSON 字符串或写入文件。

从字符串解析：json.loads()
json.loads() 函数用于将 JSON 格式的字符串解析为 Python 对象（通常是字典或列表）。

import json

json_string = '{"name":" 张三 ","age": 30,"isStudent": false,"courses": ["Python","SEO"]}'
data = json.loads(json_string)

print(type(data))         # <class 'dict'>
print(data["name"])       # 张三
print(data["courses"][0]) # Python

从文件解析：json.load()
json.load() 函数用于从一个文件对象中读取 JSON 数据并解析为 Python 对象。这在处理大型 JSON 文件时非常有用。

首先，我们创建一个名为 data.json 的文件：

{
  "users": [{"id": 1, "name": "Alice", "email": "[email protected]"},
    {"id": 2, "name": "Bob", "email": "[email protected]"}
  ],
  "metadata": {
    "version": "1.0",
    "timestamp": "2023-10-27T10:00:00Z"
  }
}

然后，使用 Python 解析它：

import json

with open('data.json', 'r', encoding='utf-8') as f:
    data_from_file = json.load(f)

print(data_from_file['users'][0]['name']) # Alice
print(data_from_file['metadata']['version']) # 1.0

转换为 JSON 字符串：json.dumps()
json.dumps() 函数用于将 Python 对象（如字典、列表等）转换为 JSON 格式的字符串。

import json

python_dict = {
    "product_id": "P1001",
    "name": "智能手机",
    "price": 999.99,
    "features": ["拍照", "游戏", "通话"],
    "available": True
}

json_output_string = json.dumps(python_dict)
print(json_output_string)
# {"product_id": "P1001", "name": "智能手机", "price": 999.99, "features": ["拍照", "游戏", "通话"], "available": true}

# 美化输出：使用 indent 参数
pretty_json_output = json.dumps(python_dict, indent=4, ensure_ascii=False)
print(pretty_json_output)
# {
#     "product_id": "P1001",
#     "name": "智能手机",
#     "price": 999.99,
#     "features": [
#         "拍照",
#         "游戏",
#         "通话"
#     ],
#     "available": true
# }

ensure_ascii=False 参数对于包含非 ASCII 字符（如中文）的字符串非常重要，它确保这些字符能以原样输出，而不是编码为 uXXXX 格式。

写入文件：json.dump()
json.dump() 函数用于将 Python 对象序列化为 JSON 格式并写入一个文件对象。

import json

new_data = {
    "report_date": "2023-10-27",
    "total_sales": 125000.50,
    "top_products": [{"name": "笔记本电脑", "sales": 50000},
        {"name": "智能手表", "sales": 30000}
    ]
}

with open('report.json', 'w', encoding='utf-8') as f:
    json.dump(new_data, f, indent=4, ensure_ascii=False)

这将在 report.json 文件中写入格式化后的 JSON 数据。

访问数据 ：JSON 数据解析后即为 Python 字典和列表，因此可以通过键名和索引轻松访问。
修改数据 ：直接对解析后的 Python 字典和列表进行修改。
添加 / 删除数据 ：使用字典的 update()、pop() 或列表的 append()、remove() 等方法。

在解析 JSON 时，可能会遇到格式不正确的情况，导致 json.JSONDecodeError 异常。捕获这个异常可以增强程序的健壮性。

import json

invalid_json_string = '{"name":"John","age": 30,' # 缺少闭合括号

try:
    data = json.loads(invalid_json_string)
except json.JSONDecodeError as e:
    print(f"JSON 解析错误: {e}")
    # JSON 解析错误: Expecting property name enclosed in double quotes: line 1 column 24 (char 23)

XML 是一种标记语言，旨在传输和存储数据。它强调数据内容的语义，允许用户定义自己的标记。与 JSON 相比，XML 结构更为严谨，通常用于更复杂、需要严格验证或具有传统系统兼容性的场景。

XML 的主要组成部分包括：

元素 (Elements)：由开始标签、结束标签和其间的内容组成。
属性 (Attributes)：提供元素的额外信息，位于开始标签内。
文本 (Text)：元素标签之间的实际数据。
根元素 (Root Element)：XML 文档的最高层元素，所有其他元素都是它的子孙。

Python 的 `xml.etree.ElementTree` 模块

Python 标准库提供了 xml.etree.ElementTree（通常简写为 ET）模块，它是处理 XML 数据最常用且高效的工具之一。它以树形结构表示 XML 文档，使得遍历、查找和修改元素变得直观。

从字符串解析：ET.fromstring()
ET.fromstring() 函数用于将 XML 格式的字符串解析为一个 Element 对象，该对象代表 XML 文档的根元素。

import xml.etree.ElementTree as ET

xml_string = """
<root>
    <item id="1">
        <name>Apple</name>
        <price>1.0</price>
    </item>
    <item id="2">
        <name>Banana</name>
        <price>0.5</price>
    </item>
</root>
"""
root = ET.fromstring(xml_string)

print(root.tag) # root
for item in root.findall('item'):
    print(f"Item ID: {item.get('id')}, Name: {item.find('name').text}, Price: {item.find('price').text}")
# Item ID: 1, Name: Apple, Price: 1.0
# Item ID: 2, Name: Banana, Price: 0.5

从文件解析：ET.parse()
ET.parse() 函数用于从一个 XML 文件中读取数据并解析为一个 ElementTree 对象。然后，可以通过 getroot() 方法获取根元素。

首先，我们创建一个名为 catalog.xml 的文件：

<?xml version="1.0" encoding="UTF-8"?>
<catalog>
    <book id="bk101">
        <author>Gambardella, Matthew</author>
        <title>XML Developer's Guide</title>
        <genre>Computer</genre>
        <price>44.95</price>
        <publish_date>2000-10-01</publish_date>
        <description>An in-depth look at creating applications with XML.</description>
    </book>
    <book id="bk102">
        <author>Ralls, Kim</author>
        <title>Midnight Rain</title>
        <genre>Fantasy</genre>
        <price>5.95</price>
        <publish_date>2000-12-16</publish_date>
        <description>A young man's search for love in a post-apocalyptic world.</description>
    </book>
</catalog>

然后，使用 Python 解析它：

import xml.etree.ElementTree as ET

tree = ET.parse('catalog.xml')
root = tree.getroot()

print(f"Root element: {root.tag}") # catalog

for book in root.findall('book'):
    book_id = book.get('id')
    title = book.find('title').text
    author = book.find('author').text
    print(f"Book ID: {book_id}, Title: {title}, Author: {author}")
# Book ID: bk101, Title: XML Developer's Guide, Author: Gambardella, Matthew
# Book ID: bk102, Title: Midnight Rain, Author: Ralls, Kim

遍历子元素 ：可以直接迭代元素对象。
find(tag)：查找当前元素的第一个匹配 tag 的子元素。
findall(tag)：查找当前元素所有匹配 tag 的子元素，返回一个列表。

iter(tag=None)：递归遍历所有子孙元素。

# 承接上面的 catalog.xml 解析
for book in root.findall('book'):
    print(f"Book ID: {book.get('id')}")
    for child in book: # 遍历 book 的直接子元素
        print(f"Tag: {child.tag}, Text: {child.text}")

# 使用 XPath 表达式 (ElementTree 支持有限的 XPath)
# 查找所有 price 大于 10 的书
for book in root.findall(".//book[price>10]"): # 注意：ElementTree 的 XPath 支持有限
    print(f"Expensive Book Title: {book.find('title').text}")
# Expensive Book Title: XML Developer's Guide

修改元素文本和属性 ：

# 修改 bk101 的价格
book101 = root.find("./book[@id='bk101']")
if book101 is not None:
    price_elem = book101.find('price')
    if price_elem is not None:
        price_elem.text = '49.95' # 修改文本
    genre_elem = book101.find('genre')
    if genre_elem is not None:
        genre_elem.text = 'Technology' # 修改文本
    book101.set('category', 'programming') # 添加新属性

添加新元素 ：

new_book = ET.SubElement(root, 'book', id='bk103') # 添加新的 book 元素到 root
ET.SubElement(new_book, 'author').text = 'Doe, Jane'
ET.SubElement(new_book, 'title').text = 'Learning Python for SEO'
ET.SubElement(new_book, 'genre').text = 'Programming'
ET.SubElement(new_book, 'price').text = '29.99'
ET.SubElement(new_book, 'publish_date').text = '2023-01-15'
ET.SubElement(new_book, 'description').text = 'A guide to using Python for SEO tasks.'

删除元素 ：

# 删除 id 为 bk102 的书
for book in root.findall('book'):
    if book.get('id') == 'bk102':
        root.remove(book)
        break

写入文件：tree.write() 或 ET.ElementTree(root).write()
ElementTree 对象有一个 write() 方法，用于将修改后的 XML 树写入文件。

# 将修改后的 XML 写入新文件
tree.write('updated_catalog.xml', encoding='utf-8', xml_declaration=True)

# 打印到控制台 (需要一些额外处理来美化输出)
# 通常 ET.tostring() 会去掉缩进和换行
# from xml.dom import minidom # 引入 minidom 进行美化
# def prettify(elem):
#     rough_string = ET.tostring(elem, 'utf-8')
#     reparsed = minidom.parseString(rough_string)
#     return reparsed.toprettyxml(indent="", encoding="utf-8").decode('utf-8')

# print(prettify(root))

直接使用 ET.tostring() 默认不会美化，如果需要美化，可以结合 minidom 模块或者手动实现。

XML 解析也可能遇到格式错误，ET 模块会在解析失败时抛出 ET.ParseError 异常。

import xml.etree.ElementTree as ET

invalid_xml_string = "<root><item>text</item>" # 缺少闭合标签

try:
    root = ET.fromstring(invalid_xml_string)
except ET.ParseError as e:
    print(f"XML 解析错误: {e}")
    # XML 解析错误: mismatched tag: line 1, column 24

选择 JSON：
- Web API 和现代 Web 应用 ：几乎所有 RESTful API 都使用 JSON。
- 数据交换量大，追求轻量和速度 ：JSON 的解析速度通常比 XML 快。
- 移动应用和客户端数据 ：JSON 更适合在客户端（如浏览器、移动设备）进行处理。
- Schema 不那么严格，或动态变化 ：JSON 结构灵活。
选择 XML：
- 配置和文档 ：XML 适用于需要自描述、结构严谨的配置或文档。
- 传统企业应用和 SOAP 服务 ：许多遗留系统和企业级服务（如 SOAP）仍广泛使用 XML。
- 需要 Schema 验证和命名空间 ：XML 具备强大的 DTD/XSD 等 Schema 定义和验证能力。
- 复杂、嵌套的数据结构 ：XML 在表示复杂的层次结构时表现良好。

Python 生态系统中有许多库可以方便地进行 JSON 和 XML 之间的转换，例如 xmltodict 库。它能够将 XML 转换为 Python 字典（进而轻松转换为 JSON），反之亦然。

# 安装：pip install xmltodict
import xmltodict
import json

# XML 转 JSON
xml_data = """
<person>
    <name>Alice</name>
    <age>30</age>
    <city>New York</city>
</person>
"""
parsed_dict = xmltodict.parse(xml_data)
json_output = json.dumps(parsed_dict, indent=4)
print("XML 转 JSON:n", json_output)
# XML 转 JSON:
# {
#     "person": {
#         "name": "Alice",
#         "age": "30",
#         "city": "New York"
#     }
# }

# JSON 转 XML
json_data = '''{"book": {"@id":"bk100","title":"The Great Novel","author":"John Doe"}
}
'''
parsed_json_dict = json.loads(json_data)
xml_output = xmltodict.unparse(parsed_json_dict, pretty=True, encoding='utf-8')
print("nJSON 转 XML:n", xml_output.decode('utf-8'))
# JSON 转 XML:
# <?xml version="1.0" encoding="utf-8"?>
# <book id="bk100">
#   <title>The Great Novel</title>
#   <author>John Doe</author>
# </book>

需要注意的是，转换过程中可能会丢失一些语义信息，特别是从 XML 转换为 JSON 时，因为 XML 的属性、命名空间等概念在 JSON 中没有直接对应。

流式解析 vs. 全量加载 ：
- 对于小型文件，全量加载（如 json.load() 或 ET.parse()）通常没问题。
- 对于非常大的文件（GB 级别），全量加载可能会耗尽内存。此时应考虑流式解析。xml.etree.ElementTree 提供了 iterparse() 函数进行事件驱动的流式解析。对于 JSON，可以使用像 ijson 这样的第三方库进行流式解析。
选择合适的解析器 ：lxml 库是一个功能更强大、性能更好的 XML 处理库，它提供了对 XPath 和 XSLT 更完整的支持，适合处理复杂的 XML 任务。

在实际应用中，数据来源往往不可控。始终使用 try-except 块来捕获 json.JSONDecodeError 或 xml.etree.ElementTree.ParseError 等异常，能够确保程序在面对畸形数据时不会崩溃，而是优雅地处理错误。此外，当查找特定元素或键时，检查返回结果是否为 None 是一个好习惯。

XML 外部实体注入 (XXE)：在解析不受信任的 XML 数据时，要警惕 XXE 攻击。恶意攻击者可以通过外部实体引用读取文件、发起网络请求等。ElementTree 默认在新的 Python 版本中对外部实体是安全的，但如果使用老版本或其他库，可能需要明确禁用它们（如 ET.XMLParser(resolve_entities=False)）。
输入验证 ：无论 JSON 还是 XML，对从外部接收的数据进行严格的结构和内容验证是至关重要的，以防止数据污染和安全漏洞。

将 JSON/XML 处理逻辑封装在独立的函数或类中，提高代码的复用性和可维护性。使用有意义的变量名，并添加适当的注释，让代码更易于理解。

Python 在处理 JSON 和 XML 数据方面展现出了无与伦比的效率和灵活性。无论是简单的文件读写，还是复杂的结构化数据操作，Python 的 json 和 xml.etree.ElementTree（以及强大的第三方库如 xmltodict 和 lxml）都能让你游刃有余。掌握这些工具，你将能够更高效地进行数据解析、格式转换，从而在数据驱动的时代中脱颖而出，为你的应用程序或数据分析工作插上翅膀。现在就开始你的实践之旅吧！

正文完

发表至： Python

近一天内

0

Python 3.12+ 新特性实战：match-case 高级用法与性能优化

Python基础入门 Day126 构建异步爬虫框架：代理池与防封策略实践

Python高效解析JSON数据：JsonPath库的实践与踩坑指南

Python 字典合并与更新：从基础到深度的实践指南与性能考量

Python NLP 零基础指南：NLTK 库深度解析与情感分析实战

用 Python 处理 JSON/XML 数据：高效解析与格式转换

JSON 数据处理：轻量级数据交换的基石

Python 的 `json` 模块

1. 解析 JSON 数据 (反序列化)

2. 生成 JSON 数据 (序列化)

3. 处理 JSON 数据的常见操作

4. 错误处理

XML 数据处理：结构化数据的传统力量

Python 的 `xml.etree.ElementTree` 模块

1. 解析 XML 数据

2. 遍历和查找 XML 元素

3. 修改和创建 XML 数据

4. 写入 XML 数据 (序列化)

5. 错误处理

JSON 与 XML 的选择与转换

何时选择 JSON，何时选择 XML？

JSON 与 XML 之间的转换

处理大规模数据与最佳实践

1. 性能考虑

2. 健壮的错误处理

3. 安全性考量

4. 代码可读性与模块化

结语

Playwright page.goto(url) 详解：深入解析网页导航的最佳实践

深度解析：基于 PyTorch 实现图像分类——从数据集构建到模型训练部署全攻略

了解 Playwright：Python 自动化测试与爬虫的新工具

Playwright：现代 Web 自动化测试的终极方案

提升 Playwright 测试效率的 10 大技巧

Playwright 实战：模拟自动登录并抓取数据（以 GitHub 为例）

Python await 详解：从入门到精通

Python with 详解：从入门到精通

Playwright 处理 iframe 元素详解：深入解析网页嵌套交互

Python 基础入门 Day33 —— 并发与多线程编程

用 Python 处理 JSON/XML 数据：高效解析与格式转换

JSON 数据处理：轻量级数据交换的基石

Python 的 json 模块

1. 解析 JSON 数据 (反序列化)

2. 生成 JSON 数据 (序列化)

3. 处理 JSON 数据的常见操作

4. 错误处理

XML 数据处理：结构化数据的传统力量

Python 的 xml.etree.ElementTree 模块

1. 解析 XML 数据

2. 遍历和查找 XML 元素

3. 修改和创建 XML 数据

4. 写入 XML 数据 (序列化)

5. 错误处理

JSON 与 XML 的选择与转换

何时选择 JSON，何时选择 XML？

JSON 与 XML 之间的转换

处理大规模数据与最佳实践

1. 性能考虑

2. 健壮的错误处理

3. 安全性考量

4. 代码可读性与模块化

结语

Python 的 `json` 模块

Python 的 `xml.etree.ElementTree` 模块