Python 有三种方法解析 XML：ElementTree、SAX 以及 DOM。

使用 ElementTree 解析 xml

xml.etree.ElementTree 是 Python 标准库中用于处理 XML 的模块。

ElementTree 和 Element 对象:

• ElementTree： ElementTree 类是 XML 文档的树形表示。它包含一个或多个 Element 对象，代表整个 XML 文档。
• Element： Element 对象是 XML 文档中元素的表示。每个元素都有一个标签、一组属性和零个或多个子元素。

ET.ElementTree()

ET.ElementTree() 是 xml.etree.ElementTree 模块中的一个类，它用于创建一个 ElementTree 对象，这个对象可以包含一个完整的 XML 文档树结构。通过这个类，你可以方便地操作整个 XML 文档，包括解析、创建、修改和写入 XML 数据。

当你创建一个 ElementTree 对象时，你通常需要提供一个根元素（Root Element）作为参数。这个根元素是整个 XML 文档的顶级元素，所有的其他元素都会作为它的子元素存在。

以下是 ET.ElementTree() 类的一些常用方法：

1. parse(): 解析一个 XML 文件或字符串，并返回一个 ElementTree 对象。
2. write(): 将 ElementTree 对象写入到一个文件或文件对象中。
3. find(): 在 ElementTree 对象中查找与指定路径或标签名匹配的元素。
4. findall(): 在 ElementTree 对象中查找所有与指定路径或标签名匹配的元素。

import xml.etree.ElementTree as ET

# 创建根元素
root = ET.Element('bookstore')

# 创建子元素并添加到根元素
book = ET.SubElement(root, 'book', category='cooking', lang='en')
title = ET.SubElement(book, 'title', lang='en')
title.text = 'Everyday Italian'
author = ET.SubElement(book, 'author')
author.text = 'Giada De Laurentiis'

# 创建 ElementTree 对象
tree = ET.ElementTree(root)

# 写入到文件
tree.write('example.xml', encoding='utf-8', xml_declaration=True)

# 解析文件并获取 ElementTree 对象
new_tree = ET.parse('example.xml')
new_root = new_tree.getroot()

# 查找特定的元素
for book in new_root.findall('book'):
    print(f"Book Category: {book.attrib['category']}")
    print(f"Book Language: {book.attrib['lang']}")
    print(f"Book Title: {book.find('title').text}")
    print("-" * 40)

解析xml

fromstring()

fromstring() 函数是该模块提供的一个便捷方法，用于将包含 XML 数据的字符串解析为一个 Element 对象，这个对象是 XML 树结构中的一个节点。

fromstring() 函数特别有用，当你需要从一个 XML 格式的字符串直接创建一个 Element 对象时。这个函数属于 xml.etree.ElementTree 模块，它能够解析 XML 字符串并返回一个 Element 对象，你可以对这个对象进行进一步的操作，比如提取数据、修改 XML 结构等。

以下是一个使用 fromstring() 函数的示例：

import xml.etree.ElementTree as ET

# 假设我们有一个 XML 格式的字符串
xml_string = """
<bookstore>
  <book category="cooking">
    <title lang="en">Everyday Italian</title>
    <author>Giada De Laurentiis</author>
    <year>2005</year>
    <price>30.00</price>
  </book>
  <book category="children">
    <title lang="en">Harry Potter</title>
    <author>J.K. Rowling</author>
    <year>2005</year>
    <price>29.99</price>
  </book>
  <book category="web">
    <title lang="en">Learning XML</title>
    <author>Erik T. Ray</author>
    <year>2003</year>
    <price>39.95</price>
  </book>
</bookstore>
"""

# 使用 fromstring() 方法将 XML 字符串解析为 Element 对象
root = ET.fromstring(xml_string)

# 打印解析后的 Element 对象的 tag 和 text
print(f"Tag: {root.tag}, Text: {root.text}")

# 可以通过遍历 Element 对象的子节点来访问 XML 数据
for child in root:
    print(f"Title: {child.find('title').text}")
    print(f"Author: {child.find('author').text}")
    print(f"Year: {child.find('year').text}")
    print(f"Price: {child.find('price').text}")
    print("-" * 40)

在这个例子中，首先定义了一个包含多个书籍信息的 XML 字符串。然后，使用 fromstring() 函数将这个字符串解析为一个 Element 对象。通过这个 Element 对象，我们可以访问 XML 文档中的各种信息，例如书名、作者、出版年份和价格。

parse()

parse() 函数是 xml.etree.ElementTree 模块中的另一个重要方法，它用于解析 XML 文件并返回一个 ElementTree 对象，该对象包含了整个 XML 文档的树形结构。与 fromstring() 方法不同，parse() 方法用于从文件对象读取 XML 数据，而 fromstring() 则是用于从字符串读取 XML 数据。

使用 parse() 方法时，你需要提供一个打开的文件对象（例如，使用 open() 函数返回的对象），该文件对象包含 XML 数据。parse() 方法会读取文件内容，并构建出一个 ElementTree 对象，你可以使用这个对象来访问和操作 XML 文档的结构和数据。

以下是一个使用 parse() 方法的示例：

import xml.etree.ElementTree as ET

# 假设我们有一个名为 'example.xml' 的 XML 文件
# 文件内容与之前提供的 XML 字符串相同

# 使用 open() 函数以读取模式打开 XML 文件
with open('example.xml', 'r') as xml_file:
    # 使用 parse() 方法解析 XML 文件并返回 ElementTree 对象
    tree = ET.parse(xml_file)

    # 根元素可以通过 getroot() 方法获取
    root = tree.getroot()
    print(f"Root Element: {root.tag}")

    # 可以通过根元素来访问 XML 文档中的所有子元素
    for child in root:
        print(f"Book Title: {child.find('title').text}")
        print(f"Book Author: {child.find('author').text}")
        print(f"Book Year: {child.find('year').text}")
        print(f"Book Price: {child.find('price').text}")
        print("-" * 40)

在这个例子中，我们首先打开了一个名为 example.xml 的文件，该文件包含了 XML 数据。然后，我们使用 parse() 方法来解析这个文件，并获取到一个 ElementTree 对象。通过调用 getroot() 方法，我们可以获取到 XML 文档的根元素。之后，我们可以遍历根元素的子元素，提取出每本书的标题、作者、出版年份和价格等信息。

parse() 方法是处理存储在文件中的 XML 数据的有效方式，它允许你构建出一个完整的 XML 树形结构，从而可以方便地对整个 XML 文档进行解析和操作。

getroot()

getroot() 是 xml.etree.ElementTree 模块中的一个方法，它用于获取解析后的 XML 文档的根元素。当你使用 parse() 函数从文件中解析 XML 数据时，它会返回一个 ElementTree 对象，该对象包含了整个 XML 文档的树形结构。通过这个 ElementTree 对象，你可以调用 getroot() 方法来访问 XML 文档的根节点。

根节点是 XML 文档结构的最顶层元素，它包含了所有的子元素和数据。通过访问根节点，你可以开始遍历整个 XML 文档，查找特定的元素，提取数据或者对 XML 结构进行修改。

find() 

find() 用于在当前 Element 对象的子元素中查找与指定路径或标签名匹配的第一个元素。这个方法非常有用，当你需要在 XML 文档中定位到特定的元素并对其进行操作时。

find() 方法可以接受两个参数：

1. path：这是一个字符串，表示从当前 Element 向下查找的 XPath 路径。XPath 是一种在 XML 和 HTML 文档中查找信息的语言。你可以使用标签名、属性和其他选择器来构建路径。
2. namespaces：这是一个可选的字典，用于指定命名空间的前缀和 URI。如果你的 XML 文档使用了命名空间，你需要提供这个参数来正确解析路径。

find() 方法返回与指定路径或标签名匹配的第一个 Element 对象，如果没有找到匹配的元素，则返回 None。

以下是一个使用 find() 方法的示例：

import xml.etree.ElementTree as ET

# 假设我们有一个名为 'example.xml' 的 XML 文件
# 文件内容如下：
'''
<bookstore>
  <book category="cooking">
    <title lang="en">Everyday Italian</title>
    <author>Giada De Laurentiis</author>
  </book>
  <book category="children">
    <title lang="en">Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
</bookstore>
'''

# 解析 XML 文件并获取根元素
root = ET.parse('example.xml').getroot()

# 使用 find() 方法查找第一个 <book> 元素
first_book = root.find('book')

# 打印找到的 <book> 元素的标题
title_element = first_book.find('title')
if title_element is not None:
    print(f"Book Title: {title_element.text}")

# 使用 XPath 路径查找特定的 <book> 元素
cooking_book = root.find('.//book[@category="cooking"]')

# 打印找到的烹饪类书籍的作者
if cooking_book is not None:
    author_element = cooking_book.find('author')
    if author_element is not None:
        print(f"Cooking Book Author: {author_element.text}")

在这个示例中，我们首先解析了一个名为 example.xml 的 XML 文件，并获取了根元素。然后，我们使用 find() 方法查找了第一个 <book> 元素，并打印出了它的标题。接着，我们使用了一个 XPath 路径来查找分类为 "cooking" 的书籍，并打印出了它的作者信息。

find() 方法是处理 XML 数据时的一个非常有用的工具，它允许你快速定位到 XML 文档中的特定元素，并对其进行操作。通过结合使用标签名和 XPath 路径，你可以灵活地在 XML 文档中导航和查询。

findall() 方法： 使用 findall() 方法可以查找具有指定标签的所有子元素：

attrib 属性

在 xml.etree.ElementTree 模块中，每个 Element 对象都有一个 attrib 属性，它是一个字典，用于存储与该元素关联的属性。属性通常以名称和值对的形式存在，名称是属性的名称，值是属性的值。这个属性在解析 XML 文档时特别有用，因为它允许你访问元素的属性，如类名、ID、样式等。

当你使用 xml.etree.ElementTree 模块解析一个 XML 文档时，所有的属性都会被读取并存储在 Element 对象的 attrib 属性中。你可以像访问普通字典一样访问 attrib 属性。

以下是一个使用 attrib 属性的示例：

import xml.etree.ElementTree as ET

# 假设我们有一个包含属性的 XML 字符串
xml_string = """
<bookstore>
  <book category="cooking" lang="en">
    <title>Everyday Italian</title>
    <author>Giada De Laurentiis</author>
  </book>
  <book category="children" lang="en">
    <title>Harry Potter</title>
    <author>J.K. Rowling</author>
  </book>
</bookstore>
"""

# 解析 XML 字符串并获取根元素
root = ET.fromstring(xml_string)

# 遍历根元素的所有 <book> 子元素
for book in root.findall('book'):
    # 打印每个 <book> 元素的属性
    print(f"Book Category: {book.attrib['category']}")
    print(f"Book Language: {book.attrib['lang']}")
    print("-" * 40)

在这个示例中，我们首先定义了一个包含两个 <book> 元素的 XML 字符串，每个元素都有 category 和 lang 属性。然后，我们使用 fromstring() 方法将这个字符串解析为一个 Element 对象，并获取根元素。接着，我们使用 findall() 方法找到所有的 <book> 子元素，并遍历它们。对于每个 <book> 元素，我们通过 attrib 属性访问并打印了它的 category 和 lang 属性。

text 属性

text 属性用于获取或设置与 Element 对象关联的文本内容。这个属性通常用于访问或修改元素内的纯文本数据。需要注意的是，text 属性可能包含空白字符，如空格、换行符和制表符等。

创建xml

Element() 

Element() 函数是 xml.etree.ElementTree 模块中的一个构造函数，用于创建一个新的 XML 元素（Element 对象）。这个函数通常用于构建 XML 文档的树结构，或者在已有的 XML 文档中添加新的元素节点。

当你调用 Element() 函数时，你可以传递多个参数来初始化 Element 对象：

1. tag：必需参数，表示元素的标签名。
2. attrib：可选参数，一个字典，用于指定元素的属性。
3. *children：可选参数，可以是一个或多个子元素，用于构建元素的子节点结构。

创建 Element 对象后，你可以使用 attrib 属性来添加或修改元素的属性，使用 text 属性来设置或获取元素的文本内容，以及使用 append() 方法来添加子元素。

以下是一个使用 Element() 函数的示例：

import xml.etree.ElementTree as ET

# 创建一个新的根元素
root = ET.Element('bookstore')

# 创建一个新的 <book> 元素，并设置属性和文本内容
book = ET.Element('book', attrib={'category': 'cooking', 'lang': 'en'})
book.text = 'This is a cooking book.'

# 创建 <title> 和 <author> 子元素
title = ET.Element('title')
title.text = 'Everyday Italian'

author = ET.Element('author')
author.text = 'Giada De Laurentiis'

# 将子元素添加到 <book> 元素中
book.append(title)
book.append(author)

# 将 <book> 元素添加到根元素中
root.append(book)

# 打印构建的 XML 树结构
print(ET.tostring(root, encoding='unicode'))

在这个示例中，首先创建了一个新的根元素 bookstore。然后，创建了一个新的 book 元素，并为其设置了属性和文本内容。接着，创建了 title 和 author 子元素，并将它们的文本内容分别设置为书籍的标题和作者。之后，将这些子元素添加到 book 元素中，然后将 book 元素添加到根元素 bookstore 中。最后，使用 tostring() 方法将构建的 XML 树结构转换为字符串并打印出来。

SubElement()

SubElement() 函数用于在已存在的 XML 元素下创建一个新的子元素。这个方法是 Element 类的一个方法，可以通过调用已存在的元素的 SubElement 方法来使用。它简化了创建和添加子元素到 XML 树结构的过程。

当你调用 SubElement() 方法时，你需要提供以下参数：

1. tag：必需参数，表示要创建的子元素的标签名。
2. attrib：可选参数，一个字典，用于指定子元素的属性。

SubElement() 方法会创建一个新的 Element 对象，并将其作为当前元素的子元素插入。这个方法也返回创建的 Element 对象，允许你对新创建的子元素进行进一步的操作，如设置文本内容或添加更多子元素。

以下是一个使用 SubElement() 方法的示例：

import xml.etree.ElementTree as ET

# 创建根元素
root = ET.Element('bookstore')

# 使用 SubElement() 方法创建一个新的 <book> 子元素
book = root.SubElement('book', category='cooking', lang='en')

# 为 <book> 元素创建 <title> 和 <author> 子元素
book.set('isbn', '1234567890')  # 设置属性的快捷方式
title = book.SubElement('title')
title.text = 'Everyday Italian'
author = book.SubElement('author')
author.text = 'Giada De Laurentiis'

# 打印构建的 XML 树结构
tree = ET.ElementTree(root)
print(ET.tostring(root, encoding='unicode', method='xml'))

在这个示例中，我们首先创建了一个名为 bookstore 的根元素。然后，我们使用 SubElement() 方法为根元素创建了一个 <book> 子元素，并为其设置了 category 和 lang 属性。接着，我们为 <book> 元素创建了 <title> 和 <author> 子元素，并设置了它们的文本内容。我们还使用了 set() 方法来为 <book> 元素设置了一个 isbn 属性。最后，我们使用 ElementTree() 方法将根元素转换成一个 ElementTree 对象，并使用 tostring() 方法将 XML 树结构转换为字符串并打印出来。

修改xml

1.直接赋值：你可以直接通过元素的 attrib 属性来赋新值给已有的属性，或者添加新的属性。

# 假设我们有一个名为 element 的 Element 对象，并且它有一个名为 'att1' 的属性
element = ET.Element('example')
element.set('att1', 'value1')

# 修改属性值
element.attrib['att1'] = 'new_value'

# 添加新属性
element.attrib['att2'] = 'another_value'

2.使用 set() 方法：Element 对象的 set() 方法可以用来设置属性的值。这个方法允许你通过属性名和值作为参数来设置。

# 修改属性值
element.set('att1', 'updated_value')

# 添加新属性
element.set('att3', 'new_value')

删除xml

remove() 方法可以删除元素

root.remove(title_element)

练习

创建文档，把文档保存到xml文件，再解析xml的实例

import xml.etree.ElementTree as ET

# 创建一个XML文档
root = ET.Element('bookstore')

# 添加第一本书
book1 = ET.SubElement(root, 'book')
title1 = ET.SubElement(book1, 'title')
title1.text = 'Introduction to Python'
author1 = ET.SubElement(book1, 'author')
author1.text = 'John Doe'
price1 = ET.SubElement(book1, 'price')
price1.text = '29.99'

# 添加第二本书
book2 = ET.SubElement(root, 'book')
title2 = ET.SubElement(book2, 'title')
title2.text = 'Data Science with Python'
author2 = ET.SubElement(book2, 'author')
author2.text = 'Jane Smith'
price2 = ET.SubElement(book2, 'price')
price2.text = '39.95'

# 将XML文档保存到文件
tree = ET.ElementTree(root)
tree.write('books.xml')

# 从文件中解析XML文档
parsed_tree = ET.parse('books.xml')
parsed_root = parsed_tree.getroot()

# 遍历XML树并打印书籍信息
for book in parsed_root.findall('book'):
    title = book.find('title').text
    author = book.find('author').text
    price = book.find('price').text
    print(f'Title: {title}, Author: {author}, Price: {price}')

使用 SAX 解析 xml

SAX（Simple API for XML）是一种基于事件的 XML 处理模型，它允许你逐个元素地访问 XML 文档的内容，而不是一次性将整个文档加载到内存中。这种解析方式对于处理大型 XML 文件非常有用，因为它可以减少内存消耗并提高处理速度。

Python 通过 xml.sax 模块提供了对 SAX 解析的支持。以下是使用 xml.sax 进行 XML 解析的基本步骤：

1. 创建 SAX 解析器实例：你需要创建一个解析器对象，Python 支持两种解析器：xml.sax.make_parser() 可以创建一个基于纯 Python 的解析器，或者你可以指定一个外部解析器，如 lxml.etree。

2. 定义 SAX 事件处理器：你需要定义一个或多个事件处理器类，这些类继承自 xml.sax.handler.ContentHandler 并实现其方法，以处理 XML 文档中的不同事件，如开始元素、结束元素、字符数据等。

3. 注册事件处理器：将你的事件处理器注册到解析器中，这样当解析器遇到相应的事件时，就会调用处理器中的方法。

4. 解析 XML 文档：使用解析器对象的 parse() 方法来读取和解析 XML 文档。

以下是一个使用 xml.sax 进行 SAX 解析的示例：

import xml.sax
from xml.sax import handler

class MyContentHandler(handler.ContentHandler):
    def __init__(self):
        handler.ContentHandler.__init__(self)
        self.current_element = None

    def startElement(self, name, attrs):
        self.current_element = name
        print(f"Start Element: {name}")

    def endElement(self, name):
        print(f"End Element: {name}")

    def characters(self, content):
        if self.current_element and content.strip():
            print(f"Characters in {self.current_element}: {content}")

# 创建解析器实例
parser = xml.sax.make_parser()

# 注册事件处理器
parser.setContentHandler(MyContentHandler())

# 解析 XML 文件
parser.parse(r'C:\Users\Administrator\Desktop\文件夹\解析xml\example.xml')

在这个示例中，我们首先定义了一个 MyContentHandler 类，它实现了 ContentHandler 的几个方法来处理不同的事件。然后，我们创建了一个解析器实例并将我们的事件处理器注册到它上面。最后，我们调用 parse() 方法来解析一个名为 example.xml 的文件。

当你运行这个程序时，它会打印出 XML 文档中每个元素的开始和结束事件，以及元素内的字符数据（如果存在的话）。

SAX 解析是一种高效的处理 XML 的方式，特别是对于大型文件或流式数据，它可以帮助你在不过度消耗资源的情况下处理 XML 数据。

ContentHandler 类

ContentHandler 类是 Python xml.sax 模块中的一个接口，用于处理 SAX 解析器在解析 XML 文档时产生的事件。当使用 SAX 进行 XML 解析时，解析器会遍历整个文档，并在遇到文档的不同部分时触发事件，如遇到元素的开始、结束、字符数据等。ContentHandler 类定义了这些事件的处理器，你可以继承这个类并实现其中的方法来处理这些事件。

以下是 ContentHandler 类中定义的一些常用方法，你可以重写这些方法来处理解析事件：

1. startDocument(): 在文档开始解析时调用。
2. endDocument(): 在文档解析结束时调用。
3. startElement(): 在遇到元素的开始标签时调用，参数包括元素名和属性字典。
4. endElement(): 在遇到元素的结束标签时调用，参数为元素名。
5. characters(): 在遇到元素的字符数据时调用，参数为字符串。

make_parser（）

用于创建一个 SAX 解析器对象。这个对象是 SAX 解析流程的核心，负责读取 XML 数据并触发相应的事件。你可以通过配置这个解析器对象来指定如何处理 XML 文档中的不同事件，例如通过设置内容处理器（ContentHandler）来处理文档中的数据。

setContentHandler（）

用于设置处理 SAX 解析事件的内容处理器。内容处理器是一个实现了 xml.sax.ContentHandler 接口的类实例，它定义了如何处理 XML 文档中的不同事件，如元素的开始、结束、字符数据等。

当你创建了一个自定义的内容处理器类并想要将其与 SAX 解析器关联时，你会使用 setContentHandler() 方法。这样，当解析器读取和解析 XML 文档时，它将调用内容处理器中的方法来处理相应的事件。

parse()

parse()方法是XMLReader类的实例（通常称为解析器）的一个方法，用于开始整个XML文档的解析过程。当你调用这个方法时，它会触发一系列的事件，这些事件会通知你XML文档的结构和内容，包括元素的开始、结束、文本内容等。

parse()方法可以接受两个参数：

1. 源（source）：这是一个可选参数，指定了要解析的XML数据的来源。它可以是一个文件路径字符串，一个打开的文件对象，或者一个io.BytesIO对象（如果你正在处理二进制数据）。如果省略这个参数，解析器会从标准输入读取数据。

2. 处理程序（handler）：这是另一个可选参数，指定了一个ContentHandler对象，用于接收和处理解析事件。如果你没有提供处理程序，或者提供了None，那么解析器将使用默认的处理程序，它实际上不会做任何事情。

练习：解析movies.xml

#!/usr/bin/python3

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # 元素开始调用
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print ("*****Movie*****")
         title = attributes["title"]
         print ("Title:", title)

   # 元素结束调用
   def endElement(self, tag):
      if self.CurrentData == "type":
         print ("Type:", self.type)
      elif self.CurrentData == "format":
         print ("Format:", self.format)
      elif self.CurrentData == "year":
         print ("Year:", self.year)
      elif self.CurrentData == "rating":
         print ("Rating:", self.rating)
      elif self.CurrentData == "stars":
         print ("Stars:", self.stars)
      elif self.CurrentData == "description":
         print ("Description:", self.description)
      self.CurrentData = ""

   # 读取字符时调用
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # 创建一个 XMLReader
   parser = xml.sax.make_parser()
   # 关闭命名空间
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # 重写 ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

使用xml.dom解析xml

xml.dom 是 Python 标准库中的一个模块，它提供了一个 DOM（文档对象模型）接口来处理 XML 数据。DOM 将 XML 文档表示为一个树结构，其中每个节点都是 xml.dom.minidom.Node 类的实例。使用 xml.dom 模块，你可以方便地访问和操作 XML 文档中的元素和属性。

以下是使用 xml.dom.minidom 解析 XML 的基本步骤：

1. 导入 xml.dom.minidom 模块。
2. 使用 parse() 方法解析 XML 文件或字符串。
3. 通过返回的 Document 对象访问和操作 XML 数据。

from xml.dom import minidom

# 解析 XML 文件
def parse_xml_file(file_path):
    doc = minidom.parse(file_path)
    return doc

# 解析 XML 字符串
def parse_xml_string(xml_string):
    doc = minidom.fromstring(xml_string)
    return doc

# 假设我们有一个名为 'example.xml' 的 XML 文件
xml_file_path = 'example.xml'

# 解析文件并获取 Document 对象
doc = parse_xml_file(xml_file_path)

# 访问并打印文档的根元素
root = doc.documentElement
print(f"Root Element: {root.tagName}")

# 遍历根元素的子元素
for child in root.childNodes:
    print(f"Child Element: {child.tagName}, Content: {child.textContent}")

在这个示例中，首先定义了两个函数，parse_xml_file 和 parse_xml_string，分别用于解析 XML 文件和字符串。然后使用 minidom.parse() 方法解析了一个名为 example.xml 的文件，并获取了 Document 对象。通过这个对象，可以访问 XML 文档的根元素，并遍历它的子元素。

documentElement 属性

在 XML 文档对象模型（DOM）中，documentElement 属性是一个 Document 对象的属性，它返回文档的根元素。在 XML 文档中，根元素是包含所有其他元素的最外层元素。通过 documentElement 属性，你可以快速访问 XML 文档的顶级元素，并从那里开始遍历或操作整个文档。

练习

#!/usr/bin/python3

from xml.dom.minidom import parse
import xml.dom.minidom

# 使用minidom解析器打开 XML 文档
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print ("Root element : %s" % collection.getAttribute("shelf"))

# 在集合中获取所有电影
movies = collection.getElementsByTagName("movie")

# 打印每部电影的详细信息
for movie in movies:
   print ("*****Movie*****")
   if movie.hasAttribute("title"):
      print ("Title: %s" % movie.getAttribute("title"))

   type = movie.getElementsByTagName('type')[0]
   print ("Type: %s" % type.childNodes[0].data)
   format = movie.getElementsByTagName('format')[0]
   print ("Format: %s" % format.childNodes[0].data)
   rating = movie.getElementsByTagName('rating')[0]
   print ("Rating: %s" % rating.childNodes[0].data)
   description = movie.getElementsByTagName('description')[0]
   print ("Description: %s" % description.childNodes[0].data)

hasAttribute()

hasAttribute() 方法是 DOM（文档对象模型）中 Node 接口的一部分，它用于检查一个元素是否具有指定的属性。这个方法在 Element 类中被实现，因为只有元素节点（Element 类的实例）可以拥有属性。

当你调用一个 Element 对象的 hasAttribute() 方法时，你需要传递一个字符串参数，该参数是你要检查的属性名。如果该元素具有该属性，hasAttribute() 方法返回 True；如果没有，返回 False。

getAttribute（）

getAttribute 方法是 DOM（文档对象模型）中 Element 接口的一部分，它用于获取指定属性的值。当你想要从一个元素节点中检索属性值时，可以使用这个方法。如果指定的属性存在于元素上，getAttribute 方法将返回该属性的值；如果属性不存在，则返回一个空字符串。

这个方法在 Element 类中被实现，因此只有元素节点（Element 类的实例）可以使用它。getAttribute 方法接受一个参数，即你要检索的属性名。

getElementsByTagName()

getElementsByTagName() 方法是 DOM（文档对象模型）中 Node 接口的一部分，它用于从当前节点（或文档）中检索所有后代节点，这些后代节点的标签名与提供的参数匹配。这个方法返回一个包含所有匹配元素的 NodeList 对象，你可以遍历这个列表来访问每个元素。

这个方法在 Element 类中特别有用，因为它允许你轻松地查询文档中的元素。getElementsByTagName() 方法接受一个参数，即你要搜索的标签名。这个方法对大小写不敏感，这意味着 "TAG" 和 "tag" 被认为是相同的标签名。