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

6次阅读

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

在当今数字化的世界中，数据是驱动一切的燃料。无论是 Web API 的响应、配置文件、系统间的数据交换，还是复杂的数据存储，JSON (JavaScript Object Notation) 和 XML (Extensible Markup Language) 都是最常见且至关重要的数据表示格式。它们以结构化、可读性强的方式承载着信息，使得程序和人类都能理解。

然而，仅仅拥有数据格式的知识是不足够的。如何高效、准确地解析这些数据，并根据需要进行格式转换，是任何现代开发者都必须掌握的核心技能。Python，凭借其简洁的语法、强大的标准库以及丰富的第三方生态系统，成为了处理 JSON 和 XML 数据的首选语言之一。

本文将深入探讨如何使用 Python 处理 JSON 和 XML 数据，从基础的解析、数据的读取与修改，到高级的格式转换和最佳实践，帮助您提升数据处理效率，轻松应对各种数据挑战。

JSON 因其轻量级和易于读写而广受欢迎，尤其在 Web 开发中，它是 API 数据交互的基石。Python 的 json 模块是标准库的一部分，无需安装即可使用，提供了将 JSON 字符串解析为 Python 对象以及将 Python 对象转换为 JSON 字符串的全部功能。

理解 JSON 和 Python 数据类型之间的映射关系至关重要：

JSON 类型	Python 类型
object	dict
array	list
string	str
number	int, float
boolean	True, False
null	None

json模块提供了两种主要方式来解析 JSON 数据：

json.loads(): 从 JSON 格式的字符串中加载数据，并将其转换为 Python 字典或列表。
json.load(): 从文件对象中加载 JSON 数据，并将其转换为 Python 字典或列表。这对于处理存储在文件中的 JSON 数据非常有用。

让我们通过一个例子来演示：

import json

# 示例 JSON 字符串
json_string = '''{"name":" 张三 ","age": 30,"isStudent": false,"courses": ["Python 编程 "," 数据结构 "],"address": {"street":" 北京路 100 号 ","city":" 上海 "},"grades": null
}
'''

# 1. 使用 json.loads() 解析 JSON 字符串
try:
    data = json.loads(json_string)
    print("--- 从字符串解析后的数据 ---")
    print(f"姓名: {data['name']}")
    print(f"年龄: {data['age']}")
    print(f"课程: {data['courses'][0]}")
    print(f"城市: {data['address']['city']}")
    print(f"成绩是否存在: {data['grades'] is None}")
except json.JSONDecodeError as e:
    print(f"JSON 解析错误: {e}")

# 2. 从文件中加载 JSON 数据
# 首先创建一个示例 JSON 文件
with open('data.json', 'w', encoding='utf-8') as f:
    f.write(json_string)

try:
    with open('data.json', 'r', encoding='utf-8') as f:
        file_data = json.load(f)
    print("n--- 从文件解析后的数据 ---")
    print(f"姓名: {file_data['name']}")
    print(f"课程总数: {len(file_data['courses'])}")
except FileNotFoundError:
    print("文件 data.json 未找到。")
except json.JSONDecodeError as e:
    print(f"JSON 文件解析错误: {e}")

同样，json模块也提供了两种将 Python 对象转换为 JSON 格式的方法：

json.dumps(): 将 Python 字典或列表转换为 JSON 格式的字符串。
json.dump(): 将 Python 字典或列表写入到文件对象中，保存为 JSON 格式。

在生成 JSON 时，我们经常需要使其更具可读性，这可以通过 indent 参数实现美化输出。

# 一个 Python 字典
python_data = {
    "product": "Python 编程指南",
    "price": 99.99,
    "available": True,
    "features": [{"name": "章节数", "value": 20},
        {"name": "页数", "value": 500}
    ],
    "publisher": None
}

# 1. 使用 json.dumps() 将 Python 字典转换为 JSON 字符串
# indent 参数用于美化输出，使其更易读
json_output_string = json.dumps(python_data, indent=4, ensure_ascii=False)
print("n--- Python 对象转换为 JSON 字符串 ---")
print(json_output_string)

# 2. 将 Python 字典写入到 JSON 文件
output_filename = 'output.json'
try:
    with open(output_filename, 'w', encoding='utf-8') as f:
        json.dump(python_data, f, indent=4, ensure_ascii=False)
    print(f"n 数据已成功写入到 {output_filename}")
    # 读取验证
    with open(output_filename, 'r', encoding='utf-8') as f:
        print("n--- 写入文件后的内容 ---")
        print(f.read())
except IOError as e:
    print(f"文件写入错误: {e}")

ensure_ascii=False 参数非常重要，它可以确保中文字符在 JSON 输出中以原始形式显示，而不是被编码为 uXXXX 的形式，提高了可读性。

XML 是另一种广泛用于数据存储和传输的格式，尤其在企业级应用、SOAP Web 服务和文档标记中扮演着重要角色。Python 的标准库中提供了 xml.etree.ElementTree 模块（通常简称为 ET），它是处理 XML 的轻量级且高效的工具。对于更复杂的需求（如 XPath 1.0/2.0 支持、XSLT 转换或性能优化），lxml 库是更强大的选择，但本文主要聚焦于标准库。

ElementTree模块的核心是 Element 对象，它代表 XML 文档中的一个元素（标签）。

ET.parse(): 从 XML 文件加载数据，并返回一个 ElementTree 对象。
ET.fromstring(): 从 XML 格式的字符串加载数据，并返回根 Element 对象。

import xml.etree.ElementTree as ET

# 示例 XML 字符串
xml_string = '''<?xml version="1.0"encoding="UTF-8"?>
<bookstore>
    <book category="编程">
        <title lang="en">Python Programming</title>
        <author>Guido van Rossum</author>
        <year>1991</year>
        <price>39.99</price>
    </book>
    <book category="小说">
        <title lang="zh"> 三体 </title>
        <author> 刘慈欣 </author>
        <year>2008</year>
        <price>29.00</price>
    </book>
</bookstore>
'''

# 1. 使用 ET.fromstring() 解析 XML 字符串
print("--- 从字符串解析 XML 数据 ---")
root_from_string = ET.fromstring(xml_string)
print(f"根元素标签: {root_from_string.tag}")

# 遍历所有 'book' 元素
for book in root_from_string.findall('book'):
    title = book.find('title').text
    author = book.find('author').text
    category = book.get('category')
    print(f"类别: {category}, 标题: {title}, 作者: {author}")

# 2. 从文件加载 XML 数据
# 创建一个示例 XML 文件
with open('books.xml', 'w', encoding='utf-8') as f:
    f.write(xml_string)

try:
    tree = ET.parse('books.xml')
    root_from_file = tree.getroot()
    print("n--- 从文件解析 XML 数据 ---")
    print(f"根元素标签: {root_from_file.tag}")

    # 查找特定属性的元素
    for book in root_from_file.findall("book/[@category=' 编程 ']"):
        title_element = book.find('title')
        print(f"找到编程类书籍: {title_element.text} (语言: {title_element.get('lang')})")

except FileNotFoundError:
    print("文件 books.xml 未找到。")
except ET.ParseError as e:
    print(f"XML 文件解析错误: {e}")

ElementTree提供了多种方法来导航和查找 XML 树中的元素：

element.tag: 获取元素的标签名。
element.text: 获取元素的文本内容。
element.get('attr_name'): 获取元素的指定属性值。
element.set('attr_name', 'attr_value'): 设置元素的属性值。
element.find('tag_name'): 查找当前元素的第一个子元素。
element.findall('tag_name'): 查找当前元素的所有子元素。支持基本的 XPath 路径。
element.iter(): 遍历当前元素及其所有后代元素。

ElementTree不仅可以解析，还可以方便地修改现有 XML 或从头创建新的 XML 结构。

# 基于之前的 tree 对象进行修改
print("n--- 修改 XML 数据 ---")
# 找到第一本编程书籍，修改价格
programming_book = root_from_file.find("book/[@category=' 编程 ']")
if programming_book is not None:
    price_element = programming_book.find('price')
    if price_element is not None:
        old_price = price_element.text
        price_element.text = '45.00' # 修改价格
        print(f"Python Programming 的价格已从 {old_price} 修改为 {price_element.text}")

    # 添加一个新属性
    programming_book.set('discount', '10%')
    print(f"Python Programming 已添加 discount 属性: {programming_book.get('discount')}")

# 添加一本新书
print("n--- 添加新元素 ---")
new_book = ET.SubElement(root_from_file, 'book', category='历史')
new_title = ET.SubElement(new_book, 'title', lang='zh')
new_title.text = '人类简史'
ET.SubElement(new_book, 'author').text = '尤瓦尔·赫拉利'
ET.SubElement(new_book, 'year').text = '2014'
ET.SubElement(new_book, 'price').text = '58.50'

# 保存修改后的 XML 到新文件
output_xml_filename = 'modified_books.xml'
tree.write(output_xml_filename, encoding='utf-8', xml_declaration=True, pretty_print=True) # pretty_print 仅 lxml 支持
# ElementTree 标准库的 write 方法没有 pretty_print 参数，如果需要美化输出，需要额外处理，或使用 lxml
# 对于标准库，我们可以使用 minidom 或自行实现简单的美化，这里为了简洁，先直接写入
# 如果是 ElementTree，通常需要手动调整，或写入后用其他工具美化。# 以下是 ElementTree 标准库的写入方式（不带 pretty_print）tree.write(output_xml_filename, encoding='utf-8', xml_declaration=True)
print(f"修改后的 XML 数据已保存到 {output_xml_filename}")

# 从头创建 XML 文档
print("n--- 从头创建 XML 文档 ---")
root_new = ET.Element('catalog')
item1 = ET.SubElement(root_new, 'item', id='001')
ET.SubElement(item1, 'name').text = '苹果'
ET.SubElement(item1, 'price').text = '10.5'

item2 = ET.SubElement(root_new, 'item', id='002')
ET.SubElement(item2, 'name').text = '香蕉'
ET.SubElement(item2, 'price').text = '5.8'

new_tree = ET.ElementTree(root_new)
new_tree_filename = 'new_catalog.xml'
new_tree.write(new_tree_filename, encoding='utf-8', xml_declaration=True)
print(f"新的 XML 文档已创建并保存到 {new_tree_filename}")

在处理外部数据时，错误处理是必不可少的一环。当 JSON 或 XML 格式不正确时，Python 会抛出特定的异常。使用 try-except 块可以优雅地捕获并处理这些错误。

JSON: json.JSONDecodeError
XML: xml.etree.ElementTree.ParseError

import json
import xml.etree.ElementTree as ET

invalid_json = "{'name':' 错误的 JSON'}" # 使用单引号，JSON 只接受双引号
invalid_xml = "<root><item> 未闭合" # 未闭合标签

try:
    json.loads(invalid_json)
except json.JSONDecodeError as e:
    print(f"nJSON 解析错误捕获: {e}")

try:
    ET.fromstring(invalid_xml)
except ET.ParseError as e:
    print(f"XML 解析错误捕获: {e}")

对于非常大的 JSON 或 XML 文件，一次性将所有内容加载到内存中可能会导致内存溢出。

JSON: 对于行分隔的 JSON（JSON Lines），可以逐行读取和解析。对于单个大 JSON 文件，如果结构允许，可以考虑使用 ijson 这样的第三方库进行流式解析。
XML: xml.etree.ElementTree.iterparse()是一个强大的工具，它允许您在 XML 解析过程中实时获取元素，而无需将整个文档加载到内存中。

# 示例：使用 iterparse 处理大型 XML
# 假设有一个非常大的 books.xml 文件
# 我们只想获取每个书名，而不把整个树加载到内存

# 重新创建一个较大的模拟 XML 文件
with open('large_books.xml', 'w', encoding='utf-8') as f:
    f.write('<?xml version="1.0"encoding="UTF-8"?>n<bookstore>n')
    for i in range(1000): # 模拟 1000 本书
        f.write(f'''<book id="{i+1}"category=" 编程 ">
        <title lang="en">Book Title {i+1}</title>
        <author>Author {i+1}</author>
        <year>2000</year>
        <price>19.99</price>
    </book>
''')
    f.write('</bookstore>')

print("n--- 使用 iterparse 处理大型 XML ---")
for event, elem in ET.iterparse('large_books.xml', events=('end',)):
    if elem.tag == 'book':
        title = elem.find('title')
        if title is not None:
            # print(f"解析到书籍: {title.text}")
            pass # 实际应用中会在这里处理数据，例如存储到数据库或进行分析
        elem.clear() # 清除已处理的元素，释放内存
print("大型 XML 文件处理完成 (通过 iterparse 模拟)。")

将 JSON 转换为 XML 或将 XML 转换为 JSON 是常见的数据集成需求。虽然没有直接的 Python 标准库函数可以一步完成，但我们可以利用 Python 字典作为中间媒介进行转换。

XML 转 JSON:
1. 解析 XML 为 Python 的 ElementTree 对象。
2. 遍历ElementTree，将其结构转换为 Python 字典（递归处理）。
3. 使用 json.dumps() 将 Python 字典转换为 JSON 字符串。
- 第三方库如 xmltodict 可以非常方便地完成这个任务。
JSON 转 XML:
1. 解析 JSON 为 Python 字典。
2. 递归遍历 Python 字典，创建对应的 ElementTree 元素。
3. 使用 tree.write() 将ElementTree对象写入 XML 文件或字符串。

让我们用 xmltodict 来演示 XML 到 JSON 的转换：

import xmltodict
import json

xml_data = '''
<note>
    <to>Tove</to>
    <from>Jani</from>
    <heading>Reminder</heading>
    <body>Don't forget me this weekend!</body>
</note>
'''

# XML 转 Python 字典
ordered_dict_data = xmltodict.parse(xml_data)
# Python 字典转 JSON 字符串
json_data = json.dumps(ordered_dict_data, indent=4, ensure_ascii=False)

print("n--- XML 转 JSON (使用 xmltodict) ---")
print(json_data)

# JSON 转 XML (使用 xmltodict)
json_input = '''{"root": {"person": [{"name": "Alice", "age": 30},
            {"name": "Bob", "age": 24}
        ],
        "city": "New York"
    }
}
'''
python_dict = json.loads(json_input)
xml_output = xmltodict.unparse(python_dict, pretty=True, encoding='utf-8')

print("n--- JSON 转 XML (使用 xmltodict) ---")
print(xml_output)

xmltodict库极大地简化了 XML 与 Python 字典之间的双向转换，从而间接实现了 XML 与 JSON 的转换，是处理这类任务的强大工具。

为了确保数据的完整性和符合预期结构，数据验证至关重要。

JSON Schema: JSON 的结构可以通过 JSON Schema 进行定义和验证。Python 有 jsonschema 这样的库来执行验证。
XML DTD/XSD: XML 的结构可以通过 DTD（Document Type Definition）或 XSD（XML Schema Definition）进行定义。lxml库提供了验证 XML 文档 against DTD/XSD 的功能。

Web API 集成: 绝大多数 RESTful API 都使用 JSON 进行数据交互。Python 是获取、解析 API 响应的理想选择。
配置文件: JSON 和 XML 常用于存储应用程序的配置信息，使得配置更具可读性和可管理性。
数据交换: 在不同的系统或服务之间进行数据传输时，JSON 和 XML 作为通用的数据格式，是实现互操作性的关键。
数据存储与日志: 结构化数据可以以 JSON 或 XML 格式存储在文件系统中，或作为日志的一部分。
数据抓取与解析: 从 HTML 或 XML 页面中提取特定数据，如爬虫应用。

Python 在处理 JSON 和 XML 数据方面提供了无与伦比的灵活性和强大功能。通过其内置的 json 和xml.etree.ElementTree模块，您可以轻松地解析、创建、修改和转换这两种流行的数据格式。而当标准库不足以满足更高级的需求（如性能、复杂的 XPath 或格式转换）时，lxml、xmltodict和 jsonschema 等第三方库则能提供更强大的支持。

掌握这些技能不仅能让您更高效地处理数据，更能让您在数据驱动的开发世界中游刃有余。现在，是时候将这些知识付诸实践，提升您的数据处理效率了！

正文完