一文看懂Python对XML文件序列化与反序列化解析教程（小白版）

一文看懂Python对XML文件序列化与反序列化解析教程（小白版）

前言

XML（可扩展标记语言）是一种广泛使用的数据交换格式，它具有良好的可读性和自我描述性。在Python开发中，我们经常需要处理XML数据，比如读取配置文件、交换数据等。本教程将详细介绍在Python中如何进行XML的序列化和反序列化操作，帮助小白快速掌握这一技能。

目录

• 一、XML基础概念
• 二、Python中处理XML的主要模块
• 三、使用xml.etree.ElementTree
• 四、简单XML的解析与生成
• 五、包含列表的复杂XML
• 六、嵌套XML的解析与生成
• 七、使用minidom处理XML
• 八、使用xmltodict简化XML处理
• 九、对象和XML之间的序列化与反序列化
• 十、实际应用场景
• 十一、常见问题与解决方案
• 十二、总结

一、XML基础概念

XML是一种标记语言，类似于HTML，但它设计用来传输和存储数据，而不是显示数据。XML的基本组成部分包括：

1. XML文档结构

1. <?xml version="1.0" encoding="UTF-8"?>
2. <root>
3. <child attribute="value">内容</child>
4. </root>

复制代码

2. XML的基本元素

• 声明：如
• 根元素：XML文档必须有一个根元素，如上面的
• 元素：由开始标签和结束标签组成，如和
• 属性：提供元素的额外信息，如attribute="value"
• 内容：元素中的文本，如上面的"内容"

二、Python中处理XML的主要模块

Python提供了多个处理XML的模块，主要包括：

1. xml.etree.ElementTree：轻量级、快速的XML处理模块，Python标准库
2. xml.dom.minidom：DOM（文档对象模型）风格的XML处理模块，Python标准库
3. lxml：第三方库，功能更强大，性能更好，但需要单独安装
4. xmltodict：第三方库，可以轻松地在XML和Python字典之间转换

本教程主要介绍Python标准库中的xml.etree.ElementTree和第三方库xmltodict，它们是最常用且易于上手的工具。

三、使用xml.etree.ElementTree

xml.etree.ElementTree模块提供了一个轻量级、高效的API，用于解析和创建XML数据。

1. 导入模块

首先，我们需要导入ElementTree模块：

1. import xml.etree.ElementTree as ET

复制代码

2. ElementTree的基本概念

• Element：表示XML中的一个元素
• ElementTree：表示整个XML文档
• 解析：将XML字符串或文件转换为ElementTree对象
• 生成：将ElementTree或Element对象转换为XML字符串或写入文件

四、简单XML的解析与生成

让我们从最简单的例子开始，学习如何解析和生成简单的XML数据。

1. 解析简单XML

假设我们有一个名为person.xml的文件，内容如下：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <person>
3. <name>张三</name>
4. <age>30</age>
5. <email>zhangsan@example.com</email>
6. </person>

复制代码

以下是解析这个XML文件的代码：

1. import xml.etree.ElementTree as ET
3. # 解析XML文件
4. tree = ET.parse('person.xml')
6. # 获取根元素
7. root = tree.getroot()
9. # 打印根元素标签
10. print(f"根元素标签: {root.tag}")
12. # 遍历所有子元素
13. for child in root:
14. print(f"标签: {child.tag}, 文本: {child.text}")
16. # 直接访问特定标签的内容
17. name = root.find('name').text
18. age = root.find('age').text
19. email = root.find('email').text
21. print(f"\n姓名: {name}")
22. print(f"年龄: {age}")
23. print(f"邮箱: {email}")

复制代码

运行结果：

1. 根元素标签: person
2. 标签: name, 文本: 张三
3. 标签: age, 文本: 30
4. 标签: email, 文本: zhangsan@example.com
6. 姓名: 张三
7. 年龄: 30
8. 邮箱: zhangsan@example.com

复制代码

2. 生成简单XML

下面是创建上述XML文件的代码：

1. import xml.etree.ElementTree as ET
3. # 创建根元素
4. person = ET.Element('person')
6. # 创建子元素并添加文本
7. name = ET.SubElement(person, 'name')
8. name.text = '张三'
10. age = ET.SubElement(person, 'age')
11. age.text = '30'
13. email = ET.SubElement(person, 'email')
14. email.text = 'zhangsan@example.com'
16. # 创建ElementTree对象
17. tree = ET.ElementTree(person)
19. # 写入XML文件
20. tree.write('person.xml', encoding='UTF-8', xml_declaration=True)
22. print("XML文件已成功创建!")
24. # 也可以将XML转换为字符串输出
25. xml_str = ET.tostring(person, encoding='UTF-8').decode('UTF-8')
26. print("\n生成的XML内容:")
27. print(xml_str)

复制代码

运行结果：

1. XML文件已成功创建!
3. 生成的XML内容:
4. <person><name>张三</name><age>30</age><email>zhangsan@example.com</email></person>

复制代码

五、包含列表的复杂XML

接下来，我们学习如何处理包含列表的更复杂的XML结构。

1. 解析包含列表的XML

假设我们有一个名为classroom.xml的文件，内容如下：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <classroom>
3. <class_name>高三(1)班</class_name>
4. <teacher>王老师</teacher>
5. <students>
6. <student>
7. <id>1</id>
8. <name>张三</name>
9. <age>18</age>
10. </student>
11. <student>
12. <id>2</id>
13. <name>李四</name>
14. <age>17</age>
15. </student>
16. <student>
17. <id>3</id>
18. <name>王五</name>
19. <age>18</age>
20. </student>
21. </students>
22. </classroom>

复制代码

以下是解析这个XML文件的代码：

1. import xml.etree.ElementTree as ET
3. # 解析XML文件
4. tree = ET.parse('classroom.xml')
5. root = tree.getroot()
7. # 获取班级基本信息
8. class_name = root.find('class_name').text
9. teacher = root.find('teacher').text
11. print(f"班级: {class_name}")
12. print(f"班主任: {teacher}")
13. print("学生列表:")
15. # 获取所有学生
16. students = root.find('students')
17. for student in students.findall('student'):
18. id = student.find('id').text
19. name = student.find('name').text
20. age = student.find('age').text
21. print(f" ID: {id}, 姓名: {name}, 年龄: {age}")

复制代码

运行结果：

1. 班级: 高三(1)班
2. 班主任: 王老师
3. 学生列表:
4. ID: 1, 姓名: 张三, 年龄: 18
5. ID: 2, 姓名: 李四, 年龄: 17
6. ID: 3, 姓名: 王五, 年龄: 18

复制代码

2. 生成包含列表的XML

下面是创建上述XML文件的代码：

1. import xml.etree.ElementTree as ET
3. # 创建根元素
4. classroom = ET.Element('classroom')
6. # 添加班级信息
7. class_name = ET.SubElement(classroom, 'class_name')
8. class_name.text = '高三(1)班'
10. teacher = ET.SubElement(classroom, 'teacher')
11. teacher.text = '王老师'
13. # 创建学生列表元素
14. students = ET.SubElement(classroom, 'students')
16. # 添加第一个学生
17. student1 = ET.SubElement(students, 'student')
18. id1 = ET.SubElement(student1, 'id')
19. id1.text = '1'
20. name1 = ET.SubElement(student1, 'name')
21. name1.text = '张三'
22. age1 = ET.SubElement(student1, 'age')
23. age1.text = '18'
25. # 添加第二个学生
26. student2 = ET.SubElement(students, 'student')
27. id2 = ET.SubElement(student2, 'id')
28. id2.text = '2'
29. name2 = ET.SubElement(student2, 'name')
30. name2.text = '李四'
31. age2 = ET.SubElement(student2, 'age')
32. age2.text = '17'
34. # 添加第三个学生
35. student3 = ET.SubElement(students, 'student')
36. id3 = ET.SubElement(student3, 'id')
37. id3.text = '3'
38. name3 = ET.SubElement(student3, 'name')
39. name3.text = '王五'
40. age3 = ET.SubElement(student3, 'age')
41. age3.text = '18'
43. # 写入XML文件
44. tree = ET.ElementTree(classroom)
45. tree.write('classroom.xml', encoding='UTF-8', xml_declaration=True)
47. print("XML文件已成功创建!")

复制代码

运行后会生成classroom.xml文件，内容与上面的示例相同。

六、嵌套XML的解析与生成

嵌套XML是指XML中包含复杂的层次结构。在Python中，我们可以通过嵌套的方式访问和创建这些结构。

1. 解析嵌套XML

假设我们有一个名为company.xml的文件，内容如下：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <company>
3. <name>科技公司</name>
4. <address>
5. <street>科技园路100号</street>
6. <city>深圳</city>
7. <province>广东</province>
8. <zipcode>518000</zipcode>
9. </address>
10. <departments>
11. <department>
12. <name>研发部</name>
13. <manager>张经理</manager>
14. <employees>
15. <employee>
16. <id>1001</id>
17. <name>李四</name>
18. <position>高级开发工程师</position>
19. <contact>
20. <phone>13800138001</phone>
21. <email>lisi@example.com</email>
22. </contact>
23. </employee>
24. <employee>
25. <id>1002</id>
26. <name>王五</name>
27. <position>产品经理</position>
28. <contact>
29. <phone>13900139002</phone>
30. <email>wangwu@example.com</email>
31. </contact>
32. </employee>
33. </employees>
34. </department>
35. </departments>
36. </company>

复制代码

以下是解析这个XML文件的代码：

1. import xml.etree.ElementTree as ET
3. # 解析XML文件
4. tree = ET.parse('company.xml')
5. root = tree.getroot()
7. # 获取公司基本信息
8. company_name = root.find('name').text
9. print(f"公司名称: {company_name}")
11. # 获取公司地址信息
12. address = root.find('address')
13. street = address.find('street').text
14. city = address.find('city').text
15. province = address.find('province').text
16. zipcode = address.find('zipcode').text
17. print(f"公司地址: {province}{city}{street}，邮编: {zipcode}")
19. # 获取部门信息
20. print("部门信息:")
21. departments = root.find('departments')
22. for dept in departments.findall('department'):
23. dept_name = dept.find('name').text
24. manager = dept.find('manager').text
25. print(f" 部门名称: {dept_name}")
26. print(f" 部门经理: {manager}")
27. print(f" 员工列表:")
29. # 获取员工信息
30. employees = dept.find('employees')
31. for emp in employees.findall('employee'):
32. emp_id = emp.find('id').text
33. emp_name = emp.find('name').text
34. position = emp.find('position').text
36. # 获取员工联系方式
37. contact = emp.find('contact')
38. phone = contact.find('phone').text
39. email = contact.find('email').text
41. print(f" 员工ID: {emp_id}, 姓名: {emp_name}, 职位: {position}")
42. print(f" 电话: {phone}, 邮箱: {email}")

复制代码

运行结果：

1. 公司名称: 科技公司
2. 公司地址: 广东深圳市科技园路100号，邮编: 518000
3. 部门信息:
4. 部门名称: 研发部
5. 部门经理: 张经理
6. 员工列表:
7. 员工ID: 1001, 姓名: 李四, 职位: 高级开发工程师
8. 电话: 13800138001, 邮箱: lisi@example.com
9. 员工ID: 1002, 姓名: 王五, 职位: 产品经理
10. 电话: 13900139002, 邮箱: wangwu@example.com

复制代码

2. 生成嵌套XML

下面是创建上述XML文件的代码：

1. import xml.etree.ElementTree as ET
3. # 创建根元素
4. company = ET.Element('company')
6. # 添加公司名称
7. name = ET.SubElement(company, 'name')
8. name.text = '科技公司'
10. # 添加公司地址（嵌套结构）
11. address = ET.SubElement(company, 'address')
12. street = ET.SubElement(address, 'street')
13. street.text = '科技园路100号'
14. city = ET.SubElement(address, 'city')
15. city.text = '深圳'
16. province = ET.SubElement(address, 'province')
17. province.text = '广东'
18. zipcode = ET.SubElement(address, 'zipcode')
19. zipcode.text = '518000'
21. # 添加部门列表
22. departments = ET.SubElement(company, 'departments')
24. # 添加研发部
25. dept = ET.SubElement(departments, 'department')
26. dept_name = ET.SubElement(dept, 'name')
27. dept_name.text = '研发部'
28. dept_manager = ET.SubElement(dept, 'manager')
29. dept_manager.text = '张经理'
31. # 添加员工列表（嵌套结构）
32. employees = ET.SubElement(dept, 'employees')
34. # 添加第一个员工
35. emp1 = ET.SubElement(employees, 'employee')
36. emp1_id = ET.SubElement(emp1, 'id')
37. emp1_id.text = '1001'
38. emp1_name = ET.SubElement(emp1, 'name')
39. emp1_name.text = '李四'
40. emp1_pos = ET.SubElement(emp1, 'position')
41. emp1_pos.text = '高级开发工程师'
43. # 添加第一个员工的联系方式（嵌套结构）
44. contact1 = ET.SubElement(emp1, 'contact')
45. phone1 = ET.SubElement(contact1, 'phone')
46. phone1.text = '13800138001'
47. email1 = ET.SubElement(contact1, 'email')
48. email1.text = 'lisi@example.com'
50. # 添加第二个员工
51. emp2 = ET.SubElement(employees, 'employee')
52. emp2_id = ET.SubElement(emp2, 'id')
53. emp2_id.text = '1002'
54. emp2_name = ET.SubElement(emp2, 'name')
55. emp2_name.text = '王五'
56. emp2_pos = ET.SubElement(emp2, 'position')
57. emp2_pos.text = '产品经理'
59. # 添加第二个员工的联系方式（嵌套结构）
60. contact2 = ET.SubElement(emp2, 'contact')
61. phone2 = ET.SubElement(contact2, 'phone')
62. phone2.text = '13900139002'
63. email2 = ET.SubElement(contact2, 'email')
64. email2.text = 'wangwu@example.com'
66. # 写入XML文件
67. tree = ET.ElementTree(company)
68. tree.write('company.xml', encoding='UTF-8', xml_declaration=True)
70. print("嵌套XML文件已成功创建!")

复制代码

运行后会生成company.xml文件，内容与上面的示例相同。

七、使用minidom处理XML

除了ElementTree，Python还提供了xml.dom.minidom模块，它实现了Document Object Model (DOM) API，可以用于处理XML数据。

1. 解析XML（使用minidom）

1. from xml.dom import minidom
3. # 解析XML文件
4. doc = minidom.parse('person.xml')
6. # 获取根元素
7. root = doc.documentElement
9. # 获取元素
10. name = root.getElementsByTagName('name')[0].firstChild.data
11. age = root.getElementsByTagName('age')[0].firstChild.data
12. email = root.getElementsByTagName('email')[0].firstChild.data
14. print(f"姓名: {name}")
15. print(f"年龄: {age}")
16. print(f"邮箱: {email}")

复制代码

运行结果：

1. 姓名: 张三
2. 年龄: 30
3. 邮箱: zhangsan@example.com

复制代码

2. 生成XML（使用minidom）

1. from xml.dom import minidom
3. # 创建XML文档对象
4. doc = minidom.Document()
6. # 创建根元素
7. person = doc.createElement('person')
8. doc.appendChild(person)
10. # 创建name元素
11. name = doc.createElement('name')
12. name_text = doc.createTextNode('张三')
13. name.appendChild(name_text)
14. person.appendChild(name)
16. # 创建age元素
17. age = doc.createElement('age')
18. age_text = doc.createTextNode('30')
19. age.appendChild(age_text)
20. person.appendChild(age)
22. # 创建email元素
23. email = doc.createElement('email')
24. email_text = doc.createTextNode('zhangsan@example.com')
25. email.appendChild(email_text)
26. person.appendChild(email)
28. # 写入XML文件
29. with open('person_minidom.xml', 'w', encoding='utf-8') as f:
30. doc.writexml(f, addindent=' ', newl='\n', encoding='utf-8')
32. print("使用minidom创建的XML文件已成功生成!")

复制代码

运行后会生成person_minidom.xml文件，内容与前面使用ElementTree生成的类似。

八、使用xmltodict简化XML处理

xmltodict是一个第三方库，它可以让我们像处理字典一样处理XML，使操作更加直观和简洁。

1. 安装xmltodict

首先，我们需要安装xmltodict库：

1. pip install xmltodict

复制代码

2. 将XML转换为字典

1. import xmltodict
3. # 读取XML文件
4. with open('person.xml', 'r', encoding='utf-8') as f:
5. xml_string = f.read()
7. # 将XML转换为字典
8. person_dict = xmltodict.parse(xml_string)
10. # 以字典方式访问数据
11. print(f"姓名: {person_dict['person']['name']}")
12. print(f"年龄: {person_dict['person']['age']}")
13. print(f"邮箱: {person_dict['person']['email']}")
15. # 打印完整字典
16. print("\n完整字典数据:")
17. print(person_dict)

复制代码

运行结果：

1. 姓名: 张三
2. 年龄: 30
3. 邮箱: zhangsan@example.com
5. 完整字典数据:
6. OrderedDict([('person', OrderedDict([('name', '张三'), ('age', '30'), ('email', 'zhangsan@example.com')]))])

复制代码

3. 将字典转换为XML

1. import xmltodict
3. # 创建字典数据
4. person_dict = {
5. 'person': {
6. 'name': '张三',
7. 'age': '30',
8. 'email': 'zhangsan@example.com'
9. }
10. }
12. # 将字典转换为XML
13. xml_string = xmltodict.unparse(person_dict, pretty=True)
15. # 打印XML字符串
16. print("生成的XML:")
17. print(xml_string)
19. # 保存到文件
20. with open('person_xmltodict.xml', 'w', encoding='utf-8') as f:
21. f.write(xml_string)
23. print("\nXML文件已成功生成!")

复制代码

运行结果：

1. 生成的XML:
2. <?xml version="1.0" encoding="utf-8"?>
3. <person>
4. <name>张三</name>
5. <age>30</age>
6. <email>zhangsan@example.com</email>
7. </person>
9. XML文件已成功生成!

复制代码

九、对象和XML之间的序列化与反序列化

在实际开发中，我们经常需要在对象和XML之间进行转换，这就是所谓的序列化和反序列化。

1. 使用xml.etree.ElementTree实现对象序列化

下面是一个将Python对象序列化为XML的示例：

1. import xml.etree.ElementTree as ET
3. # 定义Person类
4. class Person:
5. def __init__(self, name, age, email):
6. self.name = name
7. self.age = age
8. self.email = email
10. # 序列化为XML
11. def to_xml(self, file_path=None):
12. # 创建根元素
13. person = ET.Element('person')
15. # 添加子元素
16. name_elem = ET.SubElement(person, 'name')
17. name_elem.text = self.name
19. age_elem = ET.SubElement(person, 'age')
20. age_elem.text = str(self.age)
22. email_elem = ET.SubElement(person, 'email')
23. email_elem.text = self.email
25. # 如果提供了文件路径，则保存到文件
26. if file_path:
27. tree = ET.ElementTree(person)
28. tree.write(file_path, encoding='UTF-8', xml_declaration=True)
30. # 返回XML字符串
31. return ET.tostring(person, encoding='UTF-8').decode('UTF-8')
33. # 从XML反序列化
34. @classmethod
35. def from_xml(cls, xml_source):
36. # 如果xml_source是字符串，解析为Element
37. if isinstance(xml_source, str):
38. # 如果是文件路径
39. if xml_source.endswith('.xml'):
40. tree = ET.parse(xml_source)
41. root = tree.getroot()
42. else: # 如果是XML字符串
43. root = ET.fromstring(xml_source)
44. else: # 如果已经是Element对象
45. root = xml_source
47. # 从Element中提取数据
48. name = root.find('name').text
49. age = int(root.find('age').text)
50. email = root.find('email').text
52. # 创建并返回Person对象
53. return cls(name, age, email)
55. # 测试序列化
56. person = Person('张三', 30, 'zhangsan@example.com')
57. xml_str = person.to_xml('person_obj.xml')
58. print("序列化生成的XML:")
59. print(xml_str)
61. # 测试反序列化（从文件）
62. person2 = Person.from_xml('person_obj.xml')
63. print("\n从文件反序列化:")
64. print(f"姓名: {person2.name}, 年龄: {person2.age}, 邮箱: {person2.email}")
66. # 测试反序列化（从字符串）
67. person3 = Person.from_xml(xml_str)
68. print("\n从字符串反序列化:")
69. print(f"姓名: {person3.name}, 年龄: {person3.age}, 邮箱: {person3.email}")

复制代码

运行结果：

1. 序列化生成的XML:
2. <person><name>张三</name><age>30</age><email>zhangsan@example.com</email></person>
4. 从文件反序列化:
5. 姓名: 张三, 年龄: 30, 邮箱: zhangsan@example.com
7. 从字符串反序列化:
8. 姓名: 张三, 年龄: 30, 邮箱: zhangsan@example.com

复制代码

2. 使用xmltodict实现对象序列化

下面是一个使用xmltodict实现对象序列化和反序列化的示例：

1. import xmltodict
3. # 定义Person类
4. class Person:
5. def __init__(self, name, age, email):
6. self.name = name
7. self.age = age
8. self.email = email
10. # 转换为字典
11. def to_dict(self):
12. return {
13. 'person': {
14. 'name': self.name,
15. 'age': self.age,
16. 'email': self.email
17. }
18. }
20. # 序列化为XML
21. def to_xml(self, file_path=None, pretty=True):
22. xml_str = xmltodict.unparse(self.to_dict(), pretty=pretty)
24. if file_path:
25. with open(file_path, 'w', encoding='utf-8') as f:
26. f.write(xml_str)
28. return xml_str
30. # 从XML反序列化
31. @classmethod
32. def from_xml(cls, xml_source):
33. # 如果是文件路径
34. if isinstance(xml_source, str) and xml_source.endswith('.xml'):
35. with open(xml_source, 'r', encoding='utf-8') as f:
36. xml_str = f.read()
37. else:
38. xml_str = xml_source
40. # 解析XML为字典
41. data_dict = xmltodict.parse(xml_str)
43. # 提取数据
44. person_data = data_dict['person']
45. name = person_data['name']
46. age = int(person_data['age']) # 转换为整数
47. email = person_data['email']
49. # 返回Person对象
50. return cls(name, age, email)
52. # 测试序列化
53. person = Person('张三', 30, 'zhangsan@example.com')
54. xml_str = person.to_xml('person_xmltodict_obj.xml')
55. print("使用xmltodict序列化生成的XML:")
56. print(xml_str)
58. # 测试反序列化
59. person2 = Person.from_xml('person_xmltodict_obj.xml')
60. print("\n反序列化结果:")
61. print(f"姓名: {person2.name}, 年龄: {person2.age}, 邮箱: {person2.email}")

复制代码

运行结果：

1. 使用xmltodict序列化生成的XML:
2. <?xml version="1.0" encoding="utf-8"?>
3. <person>
4. <name>张三</name>
5. <age>30</age>
6. <email>zhangsan@example.com</email>
7. </person>
9. 反序列化结果:
10. 姓名: 张三, 年龄: 30, 邮箱: zhangsan@example.com

复制代码

十、实际应用场景

1. 配置文件读写

XML常被用作应用程序的配置文件格式。下面是一个读写配置文件的示例：

1. import xml.etree.ElementTree as ET
3. class ConfigManager:
4. def __init__(self):
5. self.config = None
7. # 从文件加载配置
8. def load_config(self, file_path):
9. tree = ET.parse(file_path)
10. self.config = tree.getroot()
11. return self.config
13. # 获取配置项
14. def get_value(self, *path):
15. if not self.config:
16. raise ValueError("配置未加载")
18. element = self.config
19. for tag in path:
20. element = element.find(tag)
21. if element is None:
22. return None
24. return element.text
26. # 设置配置项
27. def set_value(self, value, *path):
28. if not self.config:
29. raise ValueError("配置未加载")
31. element = self.config
32. # 查找或创建路径上的元素
33. for tag in path[:-1]:
34. next_element = element.find(tag)
35. if next_element is None:
36. next_element = ET.SubElement(element, tag)
37. element = next_element
39. # 设置最终元素的值
40. final_tag = path[-1]
41. final_element = element.find(final_tag)
42. if final_element is None:
43. final_element = ET.SubElement(element, final_tag)
44. final_element.text = str(value)
46. # 保存配置到文件
47. def save_config(self, file_path):
48. if not self.config:
49. raise ValueError("配置未加载")
51. tree = ET.ElementTree(self.config)
52. tree.write(file_path, encoding='UTF-8', xml_declaration=True)
54. # 创建默认配置文件
55. def create_default_config(file_path):
56. # 创建根元素
57. app_config = ET.Element('AppConfig')
59. # 添加应用基本信息
60. app = ET.SubElement(app_config, 'App')
61. name = ET.SubElement(app, 'Name')
62. name.text = 'MyApplication'
63. version = ET.SubElement(app, 'Version')
64. version.text = '1.0.0'
65. debug = ET.SubElement(app, 'Debug')
66. debug.text = 'true'
68. # 添加数据库配置
69. db = ET.SubElement(app_config, 'Database')
70. provider = ET.SubElement(db, 'Provider')
71. provider.text = 'SQLite'
72. connection = ET.SubElement(db, 'ConnectionString')
73. connection.text = 'Data Source=app.db'
74. max_conn = ET.SubElement(db, 'MaxConnections')
75. max_conn.text = '10'
77. # 保存到文件
78. tree = ET.ElementTree(app_config)
79. tree.write(file_path, encoding='UTF-8', xml_declaration=True)
80. print(f"默认配置文件已创建: {file_path}")
82. # 测试代码
83. config_path = 'app_config.xml'
85. # 创建默认配置
86. create_default_config(config_path)
88. # 使用配置管理器
89. manager = ConfigManager()
90. manager.load_config(config_path)
92. # 读取配置
93. app_name = manager.get_value('App', 'Name')
94. app_version = manager.get_value('App', 'Version')
95. db_provider = manager.get_value('Database', 'Provider')
97. print(f"应用名称: {app_name}")
98. print(f"应用版本: {app_version}")
99. print(f"数据库提供商: {db_provider}")
101. # 修改配置
102. manager.set_value('1.1.0', 'App', 'Version')
103. manager.set_value('20', 'Database', 'MaxConnections')
104. manager.save_config(config_path)
106. print("配置已更新")
108. # 重新加载配置
109. manager.load_config(config_path)
110. print(f"新的应用版本: {manager.get_value('App', 'Version')}")
111. print(f"新的最大连接数: {manager.get_value('Database', 'MaxConnections')}")

复制代码

运行结果：

1. 默认配置文件已创建: app_config.xml
2. 应用名称: MyApplication
3. 应用版本: 1.0.0
4. 数据库提供商: SQLite
5. 配置已更新
6. 新的应用版本: 1.1.0
7. 新的最大连接数: 20

复制代码

2. 数据交换

在不同系统之间交换数据时，XML是一种常用的格式。下面是一个简单的数据交换示例：

1. import xml.etree.ElementTree as ET
2. import xmltodict
4. # 模拟从外部系统接收的XML数据
5. def receive_data_from_external_system():
6. return '''<?xml version="1.0" encoding="UTF-8"?>
7. <order>
8. <order_id>ORD-2023-0001</order_id>
9. <customer>
10. <name>张三</name>
11. <email>zhangsan@example.com</email>
12. <phone>13800138000</phone>
13. </customer>
14. <items>
15. <item>
16. <product_id>101</product_id>
17. <name>笔记本电脑</name>
18. <quantity>1</quantity>
19. <price>5999.99</price>
20. </item>
21. <item>
22. <product_id>102</product_id>
23. <name>无线鼠标</name>
24. <quantity>2</quantity>
25. <price>99.99</price>
26. </item>
27. </items>
28. <order_date>2023-06-15</order_date>
29. <total_amount>6199.97</total_amount>
30. </order>'''
32. # 解析接收到的XML数据
33. def process_order_xml(xml_string):
34. # 使用ElementTree解析
35. root = ET.fromstring(xml_string)
37. # 提取订单信息
38. order_id = root.find('order_id').text
39. order_date = root.find('order_date').text
40. total_amount = root.find('total_amount').text
42. # 提取客户信息
43. customer = root.find('customer')
44. customer_name = customer.find('name').text
45. customer_email = customer.find('email').text
46. customer_phone = customer.find('phone').text
48. print(f"订单编号: {order_id}")
49. print(f"订单日期: {order_date}")
50. print(f"订单总额: ¥{total_amount}")
51. print(f"客户信息: {customer_name} ({customer_email}, {customer_phone})")
52. print("订单明细:")
54. # 提取订单商品
55. items = root.find('items')
56. for item in items.findall('item'):
57. product_id = item.find('product_id').text
58. product_name = item.find('name').text
59. quantity = item.find('quantity').text
60. price = item.find('price').text
62. print(f" - {product_name} (ID: {product_id}): {quantity} x ¥{price} = ¥{float(quantity) * float(price)}")
64. # 使用xmltodict解析为字典，便于进一步处理
65. order_dict = xmltodict.parse(xml_string)
66. return order_dict
68. # 生成响应XML
69. def generate_response_xml(order_dict, status="success", message="订单处理成功"):
70. # 创建响应字典
71. response_dict = {
72. 'response': {
73. 'order_id': order_dict['order']['order_id'],
74. 'status': status,
75. 'message': message,
76. 'timestamp': '2023-06-15T10:30:00Z'
77. }
78. }
80. # 转换为XML
81. xml_response = xmltodict.unparse(response_dict, pretty=True)
82. return xml_response
84. # 测试数据交换流程
85. xml_data = receive_data_from_external_system()
86. print("接收到的XML数据:")
87. print(xml_data[:200] + "...") # 只显示部分XML
88. print("\n处理结果:")
90. # 处理数据
91. order_dict = process_order_xml(xml_data)
93. # 生成响应
94. response_xml = generate_response_xml(order_dict)
95. print("\n生成的响应XML:")
96. print(response_xml)

复制代码

运行结果：

1. 接收到的XML数据:
2. <?xml version="1.0" encoding="UTF-8"?>
3. <order>
4. <order_id>ORD-2023-0001</order_id>
5. <customer>
6. <name>张三</name>
7. <email>zhangsan@example.com</email>
8. <phone>13800138000</phone>
9. </customer>...
11. 处理结果:
12. 订单编号: ORD-2023-0001
13. 订单日期: 2023-06-15
14. 订单总额: ¥6199.97
15. 客户信息: 张三 (zhangsan@example.com, 13800138000)
16. 订单明细:
17. - 笔记本电脑 (ID: 101): 1 x ¥5999.99 = ¥5999.99
18. - 无线鼠标 (ID: 102): 2 x ¥99.99 = ¥199.98
20. 生成的响应XML:
21. <?xml version="1.0" encoding="utf-8"?>
22. <response>
23. <order_id>ORD-2023-0001</order_id>
24. <status>success</status>
25. <message>订单处理成功</message>
26. <timestamp>2023-06-15T10:30:00Z</timestamp>
27. </response>

复制代码

十一、常见问题与解决方案

1. 中文乱码问题

问题：处理包含中文的XML文件时，出现乱码。

解决方案：在读写XML文件时，显式指定编码为UTF-8。

1. import xml.etree.ElementTree as ET
3. # 正确写入带中文的XML文件
4. def write_xml_with_utf8(element, file_path):
5. tree = ET.ElementTree(element)
6. # 显式指定编码为UTF-8
7. tree.write(file_path, encoding='UTF-8', xml_declaration=True)
9. # 正确读取带中文的XML文件
10. def read_xml_with_utf8(file_path):
11. # ElementTree默认支持UTF-8
12. tree = ET.parse(file_path)
13. return tree.getroot()

复制代码

2. 解析不规范的XML

问题：处理一些不规范的XML（如没有结束标签、大小写不匹配等）。

解决方案：可以使用lxml库的recover选项，它能够处理一些不规范的XML。

首先安装lxml：

1. pip install lxml

复制代码

然后使用lxml解析不规范的XML：

1. from lxml import etree
3. def parse_non_standard_xml(xml_string):
4. # 使用lxml的HTML解析器，它更宽松，能够处理不规范的XML
5. parser = etree.HTMLParser(recover=True)
6. tree = etree.fromstring(xml_string, parser)
7. return tree
9. # 示例：解析缺少结束标签的XML
10. bad_xml = '<root><item>1<item>2</root>'
11. tree = parse_non_standard_xml(bad_xml)
12. print("成功解析不规范的XML")

复制代码

3. 处理大型XML文件

问题：直接解析大型XML文件会占用过多内存。

解决方案：使用ElementTree的迭代解析功能或SAX（Simple API for XML）解析器。

1. import xml.etree.ElementTree as ET
3. def parse_large_xml(file_path, tag_to_extract):
4. """迭代解析大型XML文件"""
5. context = ET.iterparse(file_path, events=('start', 'end'))
6. # 获取根元素
7. event, root = next(context)
9. for event, elem in context:
10. if event == 'end' and elem.tag == tag_to_extract:
11. # 处理元素
12. yield elem
13. # 清理已处理的元素，释放内存
14. root.clear()
16. # 示例：迭代解析大型XML文件中的所有<item>元素
17. for item in parse_large_xml('large_file.xml', 'item'):
18. # 处理每个item元素
19. print(f"处理元素: {item.tag}")

复制代码

4. XML命名空间处理

问题：XML中包含命名空间，导致无法直接通过标签名查找元素。

解决方案：在查找元素时指定命名空间。

1. import xml.etree.ElementTree as ET
3. # 包含命名空间的XML示例
4. xml_with_ns = '''<?xml version="1.0" encoding="UTF-8"?>
5. <root xmlns:data="http://example.org/data">
6. <data:person>
7. <data:name>张三</data:name>
8. <data:age>30</data:age>
9. </data:person>
10. </root>'''
12. # 解析包含命名空间的XML
13. root = ET.fromstring(xml_with_ns)
15. # 定义命名空间字典
16. namespaces = {'data': 'http://example.org/data'}
18. # 使用命名空间查找元素
19. person = root.find('data:person', namespaces)
20. name = person.find('data:name', namespaces).text
21. age = person.find('data:age', namespaces).text
23. print(f"姓名: {name}, 年龄: {age}")

复制代码

运行结果：

1. 姓名: 张三, 年龄: 30

复制代码

5. 添加和修改XML属性

问题：需要在XML元素中添加或修改属性。

解决方案：使用Element的set方法设置属性。

1. import xml.etree.ElementTree as ET
3. # 创建根元素
4. person = ET.Element('person')
6. # 添加属性
7. person.set('id', '1001')
8. person.set('status', 'active')
10. # 添加子元素
11. name = ET.SubElement(person, 'name')
12. name.text = '张三'
14. # 修改属性
15. person.set('status', 'inactive')
17. # 获取属性值
18. id_value = person.get('id')
19. status_value = person.get('status')
21. print(f"元素属性 - ID: {id_value}, 状态: {status_value}")

复制代码

运行结果：

1. 元素属性 - ID: 1001, 状态: inactive

复制代码

十二、总结

通过本教程，我们学习了在Python中处理XML的各种方法：

1. 基本概念：了解了XML的基本结构和Python中处理XML的主要模块
2. 使用ElementTree：学习了如何使用ElementTree解析和生成XML
3. 使用minidom：了解了如何使用minidom处理XML
4. 使用xmltodict：学习了如何使用xmltodict在XML和字典之间转换
5. 对象序列化：学习了如何在Python对象和XML之间进行序列化和反序列化
6. 实际应用场景：了解了XML在配置文件和数据交换中的应用
7. 常见问题解决方案：学习了如何处理中文乱码、不规范XML、大型XML文件等问题

Python提供了多种处理XML的方式，可以根据具体需求选择合适的方法。ElementTree是Python标准库中推荐的方式，简单易用；而xmltodict则提供了更直观的字典式访问方式，适合快速开发。

希望本教程能够帮助你快速掌握Python中XML的处理技巧，在实际项目中灵活运用。