19.7. xml.etree.ElementTree — ElementTree XML API

2.5 版中的新功能。

源代码： :source:`Lib/xml/etree/ElementTree.py`

Element 类型是一个灵活的容器对象，旨在在内存中存储分层数据结构。该类型可以描述为列表和字典之间的交叉。

警告

xml.etree.ElementTree 模块对于恶意构造的数据并不安全。如果您需要解析不受信任或未经身份验证的数据，请参阅 XML 漏洞。

每个元素都有许多与之相关的属性：

一个标签，它是一个字符串，用于标识此元素代表的数据类型（换句话说，元素类型）。
许多属性，存储在 Python 字典中。
一个文本字符串。
一个可选的尾字符串。
多个子元素，存储在 Python 序列中

要创建元素实例，请使用 Element 构造函数或 SubElement() 工厂函数。

ElementTree 类可用于包装元素结构，并将其从 XML 转换为 XML。

此 API 的 AC 实现可用作 xml.etree.cElementTree。

有关教程和其他文档的链接，请参阅 http://effbot.org/zone/element-index.htm。 Fredrik Lundh 的页面也是 xml.etree.ElementTree 开发版本的位置。

2.7 版本变化：ElementTree API 更新至 1.3。有关更多信息，请参阅 ElementTree 1.3 简介。

19.7.1. 教程

这是使用 xml.etree.ElementTree（简称 ET）的简短教程。目标是演示模块的一些构建块和基本概念。

19.7.1.1. XML 树和元素

XML 是一种固有的分层数据格式，最自然的表示方式是使用树。 ET 有两个用于此目的的类 - ElementTree 将整个 XML 文档表示为一棵树，而 Element 表示该树中的单个节点。与整个文档的交互（读写文件）通常在 ElementTree 级别上完成。与单个 XML 元素及其子元素的交互是在元素级别上完成的。

19.7.1.2. 解析 XML

我们将使用以下 XML 文档作为本节的示例数据：

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank>1</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank>4</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank>68</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

我们有多种导入数据的方法。从磁盘读取文件：

import xml.etree.ElementTree as ET
tree = ET.parse('country_data.xml')
root = tree.getroot()

从字符串中读取数据：

root = ET.fromstring(country_data_as_string)

fromstring() 将 XML 从字符串直接解析为 Element，这是解析树的根元素。其他解析函数可能会创建一个 ElementTree。检查文档以确保。

作为 Element，root 有一个标签和一个属性字典：

>>> root.tag
'data'
>>> root.attrib
{}

它还具有我们可以迭代的子节点：

>>> for child in root:
...     print child.tag, child.attrib
...
country {'name': 'Liechtenstein'}
country {'name': 'Singapore'}
country {'name': 'Panama'}

子节点是嵌套的，我们可以通过索引访问特定的子节点：

>>> root[0][1].text
'2008'

19.7.1.3. 寻找有趣的元素

Element 有一些有用的方法可以帮助递归迭代它下面的所有子树（它的子树、它们的子树等等）。例如，Element.iter()：

>>> for neighbor in root.iter('neighbor'):
...     print neighbor.attrib
...
{'name': 'Austria', 'direction': 'E'}
{'name': 'Switzerland', 'direction': 'W'}
{'name': 'Malaysia', 'direction': 'N'}
{'name': 'Costa Rica', 'direction': 'W'}
{'name': 'Colombia', 'direction': 'E'}

Element.findall() 仅查找带有标记的元素，这些元素是当前元素的直接子元素。 Element.find() 找到具有特定标签的 first 子元素，Element.text 访问元素的文本内容。 Element.get() 访问元素的属性：

>>> for country in root.findall('country'):
...     rank = country.find('rank').text
...     name = country.get('name')
...     print name, rank
...
Liechtenstein 1
Singapore 4
Panama 68

使用 XPath 可以更复杂地指定要查找的元素。

19.7.1.4. 修改 XML 文件

ElementTree 提供了一种构建 XML 文档并将其写入文件的简单方法。 ElementTree.write() 方法用于此目的。

创建后，可以通过直接更改其字段（例如 Element.text）、添加和修改属性（Element.set()）来操作 Element 对象方法），以及添加新子项（例如使用 Element.append()）。

假设我们要为每个国家/地区的排名添加一个，并向 rank 元素添加一个 updated 属性：

>>> for rank in root.iter('rank'):
...     new_rank = int(rank.text) + 1
...     rank.text = str(new_rank)
...     rank.set('updated', 'yes')
...
>>> tree.write('output.xml')

我们的 XML 现在看起来像这样：

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

我们可以使用 Element.remove() 删除元素。假设我们要删除排名高于 50 的所有国家/地区：

>>> for country in root.findall('country'):
...     rank = int(country.find('rank').text)
...     if rank > 50:
...         root.remove(country)
...
>>> tree.write('output.xml')

我们的 XML 现在看起来像这样：

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
</data>

19.7.1.5. 构建 XML 文档

SubElement() 函数还提供了一种为给定元素创建新子元素的便捷方法：

>>> a = ET.Element('a')
>>> b = ET.SubElement(a, 'b')
>>> c = ET.SubElement(a, 'c')
>>> d = ET.SubElement(c, 'd')
>>> ET.dump(a)
<a><b /><c><d /></c></a>

19.7.1.6. 使用命名空间解析 XML

如果 XML 输入具有命名空间，带有 prefix:sometag 形式前缀的标签和属性将扩展为 {uri}sometag，其中前缀被替换为完整的URI。此外，如果存在默认命名空间，则该完整 URI 将被添加到所有非前缀标签中。

这是一个包含两个命名空间的 XML 示例，一个带有前缀“fictional”，另一个用作默认命名空间：

<?xml version="1.0"?>
<actors xmlns:fictional="http://characters.example.com"
        xmlns="http://people.example.com">
    <actor>
        <name>John Cleese</name>
        <fictional:character>Lancelot</fictional:character>
        <fictional:character>Archie Leach</fictional:character>
    </actor>
    <actor>
        <name>Eric Idle</name>
        <fictional:character>Sir Robin</fictional:character>
        <fictional:character>Gunther</fictional:character>
        <fictional:character>Commander Clement</fictional:character>
    </actor>
</actors>

搜索和探索此 XML 示例的一种方法是手动将 URI 添加到 find() 或 findall() 的 xpath 中的每个标签或属性：

root = fromstring(xml_text)
for actor in root.findall('{http://people.example.com}actor'):
    name = actor.find('{http://people.example.com}name')
    print name.text
    for char in actor.findall('{http://characters.example.com}character'):
        print ' |-->', char.text

搜索命名空间 XML 示例的更好方法是使用您自己的前缀创建一个字典并在搜索函数中使用这些：

ns = {'real_person': 'http://people.example.com',
      'role': 'http://characters.example.com'}

for actor in root.findall('real_person:actor', ns):
    name = actor.find('real_person:name', ns)
    print name.text
    for char in actor.findall('role:character', ns):
        print ' |-->', char.text

这两种方法都输出：

John Cleese
 |--> Lancelot
 |--> Archie Leach
Eric Idle
 |--> Sir Robin
 |--> Gunther
 |--> Commander Clement

19.7.1.7。其他资源

有关教程和其他文档的链接，请参阅 http://effbot.org/zone/element-index.htm。

19.7.2. XPath 支持

该模块为 XPath 表达式提供有限的支持，用于定位树中的元素。目标是支持缩写语法的一小部分；完整的 XPath 引擎超出了模块的范围。

19.7.2.1. 例子

下面的示例演示了该模块的一些 XPath 功能。我们将使用 Parsing XML 部分中的 countrydata XML 文档：

import xml.etree.ElementTree as ET

root = ET.fromstring(countrydata)

# Top-level elements
root.findall(".")

# All 'neighbor' grand-children of 'country' children of the top-level
# elements
root.findall("./country/neighbor")

# Nodes with name='Singapore' that have a 'year' child
root.findall(".//year/..[@name='Singapore']")

# 'year' nodes that are children of nodes with name='Singapore'
root.findall(".//*[@name='Singapore']/year")

# All 'neighbor' nodes that are the second child of their parent
root.findall(".//neighbor[2]")

19.7.2.2. 支持的 XPath 语法

句法	意义
`tag`	选择具有给定标签的所有子元素。例如，`spam` 选择名为 `spam` 的所有子元素，而 `spam/egg` 选择名为 `spam` 的所有子元素中名为 `egg` 的所有孙元素。
`*`	选择所有子元素。例如，`*/egg` 选择所有名为 `egg` 的孙子。
`.`	选择当前节点。这在路径的开头非常有用，以表明它是一个相对路径。
`//`	选择当前元素下所有级别的所有子元素。例如，`.//egg` 选择整个树中的所有 `egg` 元素。
`..`	选择父元素。
`[@attrib]`	选择具有给定属性的所有元素。
`[@attrib='value']`	选择给定属性具有给定值的所有元素。该值不能包含引号。
`[tag]`	选择所有具有名为 `tag` 的子元素的元素。仅支持直系子女。
`[tag='text']`	选择所有具有名为 `tag` 的子元素的元素，其完整文本内容（包括后代）等于给定的 `text`。
`[position]`	选择位于给定位置的所有元素。位置可以是整数（1 是第一个位置）、表达式 `last()`（对于最后一个位置）或相对于最后一个位置的位置（例如 `last()-1`）。

谓词（方括号内的表达式）必须以标记名称、星号或其他谓词开头。 position 谓词前面必须有标记名称。

19.7.3. 参考

19.7.3.1. 职能

xml.etree.ElementTree.Comment(text=None): 注释元素工厂。此工厂函数创建一个特殊元素，该元素将被标准序列化程序序列化为 XML 注释。注释字符串可以是字节字符串或 Unicode 字符串。 text 是包含注释字符串的字符串。返回表示评论的元素实例。

xml.etree.ElementTree.dump(elem)

将元素树或元素结构写入 sys.stdout。此功能应仅用于调试。

确切的输出格式取决于实现。在这个版本中，它被写成一个普通的 XML 文件。

elem 是元素树或单个元素。

xml.etree.ElementTree.fromstring(text): 从字符串常量解析 XML 部分。与 XML() 相同。 text 是一个包含 XML 数据的字符串。返回一个 Element 实例。

xml.etree.ElementTree.fromstringlist(sequence, parser=None): 从字符串片段序列解析 XML 文档。 sequence 是包含 XML 数据片段的列表或其他序列。 parser 是一个可选的解析器实例。如果没有给出，则使用标准的 XMLParser 解析器。返回一个 Element 实例。

2.7 版中的新功能。

xml.etree.ElementTree.iselement(element): 检查对象是否显示为有效的元素对象。 element 是一个元素实例。如果这是一个元素对象，则返回一个真值。

xml.etree.ElementTree.iterparse(source, events=None, parser=None): 将 XML 部分逐步解析为元素树，并向用户报告正在发生的事情。 source 是包含 XML 数据的文件名或文件对象。 events 是要报告的事件列表。如果省略，则仅报告“结束”事件。 parser 是一个可选的解析器实例。如果没有给出，则使用标准的 XMLParser 解析器。 cElementTree 不支持 parser。返回一个 iterator 提供 (event, elem) 对。

笔记

iterparse() 只保证它在发出“start”事件时看到了起始标签的“>”字符，所以定义了属性，但未定义text和tail属性的内容在那时候。这同样适用于元素孩子；它们可能存在也可能不存在。

如果您需要一个完全填充的元素，请改为查找“结束”事件。

xml.etree.ElementTree.parse(source, parser=None): 将 XML 部分解析为元素树。 source 是包含 XML 数据的文件名或文件对象。 parser 是一个可选的解析器实例。如果没有给出，则使用标准的 XMLParser 解析器。返回一个 ElementTree 实例。

xml.etree.ElementTree.ProcessingInstruction(target, text=None): PI 元素工厂。此工厂函数创建一个特殊元素，该元素将被序列化为 XML 处理指令。 target 是一个包含 PI 目标的字符串。 text 是包含 PI 内容的字符串（如果给定）。返回一个元素实例，代表一条处理指令。

xml.etree.ElementTree.register_namespace(prefix, uri): 注册命名空间前缀。注册表是全局的，给定前缀或命名空间 URI 的任何现有映射都将被删除。 prefix 是命名空间前缀。 uri 是命名空间 uri。如果可能，此命名空间中的标签和属性将使用给定的前缀进行序列化。

2.7 版中的新功能。

xml.etree.ElementTree.SubElement(parent, tag, attrib={}, **extra)

子元素工厂。此函数创建一个元素实例，并将其附加到现有元素。

元素名称、属性名称和属性值可以是字节字符串或 Unicode 字符串。 parent 是父元素。 tag 是子元素名称。 attrib 是一个可选的字典，包含元素属性。 extra 包含附加属性，作为关键字参数给出。返回一个元素实例。

xml.etree.ElementTree.tostring(element, encoding='us-ascii', method='xml'): 生成 XML 元素的字符串表示形式，包括所有子元素。 element 是一个 Element 实例。 encoding 1 是输出编码（默认为 US-ASCII）。 method 为 "xml"、"html" 或 "text"（默认为 "xml"）。返回包含 XML 数据的编码字符串。

xml.etree.ElementTree.tostringlist(element, encoding='us-ascii', method='xml'): 生成 XML 元素的字符串表示形式，包括所有子元素。 element 是一个 Element 实例。 encoding 1 是输出编码（默认为 US-ASCII）。 method 为 "xml"、"html" 或 "text"（默认为 "xml"）。返回包含 XML 数据的编码字符串列表。它不保证任何特定的顺序，除了 "".join(tostringlist(element)) == tostring(element)。

2.7 版中的新功能。

xml.etree.ElementTree.XML(text, parser=None): 从字符串常量解析 XML 部分。此函数可用于在 Python 代码中嵌入“XML 文字”。 text 是一个包含 XML 数据的字符串。 parser 是一个可选的解析器实例。如果没有给出，则使用标准的 XMLParser 解析器。返回一个 Element 实例。

xml.etree.ElementTree.XMLID(text, parser=None): 从字符串常量解析 XML 部分，并返回从元素 id:s 映射到元素的字典。 text 是一个包含 XML 数据的字符串。 parser 是一个可选的解析器实例。如果没有给出，则使用标准的 XMLParser 解析器。返回一个包含 Element 实例和字典的元组。

19.7.3.2. 元素对象

class xml.etree.ElementTree.Element(tag, attrib={}, **extra)

元素类。该类定义了 Element 接口，并提供了该接口的参考实现。

元素名称、属性名称和属性值可以是字节字符串或 Unicode 字符串。 tag 是元素名称。 attrib 是一个可选的字典，包含元素属性。 extra 包含附加属性，作为关键字参数给出。

tag: 一个字符串，用于标识此元素代表的数据类型（换句话说，元素类型）。

text tail

这些属性可用于保存与元素关联的附加数据。它们的值通常是字符串，但也可以是任何特定于应用程序的对象。如果元素是从 XML 文件创建的，则 text 属性保存元素的开始标签与其第一个子标签或结束标签之间的文本，或 None 和 tail 之间的文本 属性保存元素的结束标记和下一个标记之间的文本，或 None。对于 XML 数据

<a><b>1<c>2<d/>3</c></b>4</a>

a 元素具有 text 和 tail 属性的 None，b 元素具有 text[ X125X] "1" 和 tail "4"，c 元素有 text [X212X][X212X] tail None，d 元素有 text None 和 tail [X334X][X349X].X3

要收集元素的内部文本，请参阅 itertext()，例如 "".join(element.itertext())。

应用程序可以在这些属性中存储任意对象。

attrib: 包含元素属性的字典。请注意，虽然 attrib 值始终是一个真正的可变 Python 字典，但 ElementTree 实现可能会选择使用另一种内部表示，并且仅在有人要求时才创建字典。要利用此类实现，请尽可能使用下面的字典方法。

以下类似字典的方法适用于元素属性。

clear(): 重置一个元素。该函数移除所有子元素，清除所有属性，并将text和tail属性设置为None。

get(key, default=None)

获取名为 key 的元素属性。

返回属性值，如果未找到属性，则返回 default。

items(): 以（名称，值）对的序列形式返回元素属性。属性以任意顺序返回。

keys(): 以列表形式返回元素属性名称。名称以任意顺序返回。

set(key, value): 将元素上的属性 key 设置为 value。

以下方法适用于元素的子元素（子元素）。

append(subelement): 将元素 subelement 添加到此元素内部子元素列表的末尾。

extend(subelements): 从具有零个或多个元素的序列对象附加 子元素 。如果子元素不是有效对象，则引发 AssertionError。

2.7 版中的新功能。

find(match): 查找第一个匹配 match 的子元素。 match 可以是标签名或路径。返回元素实例或 None。

findall(match): 按标签名称或路径查找所有匹配的子元素。返回一个包含文档顺序中所有匹配元素的列表。

findtext(match, default=None): 查找匹配 match 的第一个子元素的文本。 match 可以是标签名或路径。返回第一个匹配元素的文本内容，如果未找到元素，则返回 default。请注意，如果匹配元素没有文本内容，则返回一个空字符串。

getchildren(): 自 2.7 版起已弃用：使用 list(elem) 或迭代。

getiterator(tag=None): 自 2.7 版起已弃用：改用方法 Element.iter()。

insert(index, element): 在此元素的给定位置插入一个子元素。

iter(tag=None): 创建一个以当前元素为根的树 iterator。迭代器以文档（深度优先）顺序迭代此元素及其下方的所有元素。如果 tag 不是 None 或 '*'，则迭代器只返回标签等于 tag 的元素。如果在迭代过程中修改了树结构，结果是不确定的。

2.7 版中的新功能。

iterfind(match): 按标签名称或路径查找所有匹配的子元素。返回一个可迭代的，以文档顺序产生所有匹配的元素。

2.7 版中的新功能。

itertext(): 创建一个文本迭代器。迭代器按文档顺序遍历此元素和所有子元素，并返回所有内部文本。

2.7 版中的新功能。

makeelement(tag, attrib): 创建与此元素类型相同的新元素对象。不要调用此方法，而是使用 SubElement() 工厂函数。

remove(subelement): 从元素中移除 子元素 。与 find* 方法不同，此方法基于实例标识而不是标记值或内容比较元素。

Element 对象还支持以下用于处理子元素的序列类型方法：__delitem__()、__getitem__()、__setitem__()、 __len__()。

注意：没有子元素的元素将测试为 False。此行为将在未来版本中更改。请改用特定的 len(elem) 或 elem is None 测试。

element = root.find('foo')

if not element:  # careful!
    print "element not found, or element has no subelements"

if element is None:
    print "element not found"

19.7.3.3. 元素树对象

class xml.etree.ElementTree.ElementTree(element=None, file=None)

ElementTree 包装类。此类表示整个元素层次结构，并为标准 XML 的序列化添加了一些额外的支持。

element 是根元素。如果给定，则使用 XML 文件的内容初始化树。

_setroot(element): 替换此树的根元素。这会丢弃树的当前内容，并用给定的元素替换它。小心使用。 element 是一个元素实例。

find(match): 与 Element.find() 相同，从树的根开始。

findall(match): 与 Element.findall() 相同，从树的根开始。

findtext(match, default=None): 与 Element.findtext() 相同，从树的根开始。

getiterator(tag=None): 自 2.7 版起已弃用：改用方法 ElementTree.iter()。

getroot(): 返回此树的根元素。

iter(tag=None): 为根元素创建并返回一个树迭代器。迭代器按节顺序遍历此树中的所有元素。 tag 是要查找的标签（默认是返回所有元素）。

iterfind(match): 按标签名称或路径查找所有匹配的子元素。与 getroot().iterfind(match) 相同。返回一个可迭代的，以文档顺序产生所有匹配的元素。

2.7 版中的新功能。

parse(source, parser=None): 将外部 XML 部分加载到此元素树中。 source 是文件名或文件对象。 parser 是一个可选的解析器实例。如果没有给出，则使用标准的 XMLParser 解析器。返回节根元素。

write(file, encoding='us-ascii', xml_declaration=None, default_namespace=None, method='xml'): 将元素树作为 XML 写入文件。 file 是一个文件名，或者一个为写入而打开的文件对象。 encoding 1 是输出编码（默认为 US-ASCII）。 xml_declaration 控制是否应将 XML 声明添加到文件中。使用 False 表示从不，True 表示总是，None 仅用于非 US-ASCII 或 UTF-8（默认为 None）。 default_namespace 设置默认的 XML 命名空间（对于“xmlns”）。 method 为 "xml"、"html" 或 "text"（默认为 "xml"）。返回一个编码字符串。

这是将要操作的 XML 文件：

<html>
    <head>
        <title>Example page</title>
    </head>
    <body>
        <p>Moved to <a href="http://example.org/">example.org</a>
        or <a href="http://example.com/">example.com</a>.</p>
    </body>
</html>

更改第一段中每个链接的属性“目标”的示例：

>>> from xml.etree.ElementTree import ElementTree
>>> tree = ElementTree()
>>> tree.parse("index.xhtml")
<Element 'html' at 0xb77e6fac>
>>> p = tree.find("body/p")     # Finds first occurrence of tag p in body
>>> p
<Element 'p' at 0xb77ec26c>
>>> links = list(p.iter("a"))   # Returns list of all links
>>> links
[<Element 'a' at 0xb77ec2ac>, <Element 'a' at 0xb77ec1cc>]
>>> for i in links:             # Iterates through all found links
...     i.attrib["target"] = "blank"
...
>>> tree.write("output.xhtml")

19.7.3.4. QName 对象

class xml.etree.ElementTree.QName(text_or_uri, tag=None): QName 包装器。这可用于包装 QName 属性值，以便对输出进行正确的命名空间处理。 text_or_uri 是一个包含 QName 值的字符串，格式为 {uri}local，或者，如果给定了 tag 参数，则为 QName 的 URI 部分。如果给出 tag，第一个参数被解释为一个 URI，这个参数被解释为一个本地名称。 QName 实例是不透明的。

19.7.3.5. TreeBuilder 对象

class xml.etree.ElementTree.TreeBuilder(element_factory=None)

通用元素结构构建器。此构建器将开始、数据和结束方法调用的序列转换为格式良好的元素结构。您可以使用此类来构建使用自定义 XML 解析器或其他类似 XML 格式的解析器的元素结构。调用 element_factory 来创建新的 Element 实例。

close(): 刷新构建器缓冲区，并返回顶级文档元素。返回一个 Element 实例。

data(data): 向当前元素添加文本。 data 是一个字符串。这应该是字节字符串或 Unicode 字符串。

end(tag): 关闭当前元素。 tag 是元素名称。返回关闭的元素。

start(tag, attrs): 打开一个新元素。 tag 是元素名称。 attrs 是一个包含元素属性的字典。返回打开的元素。

此外，自定义的 TreeBuilder 对象可以提供以下方法：

doctype(name, pubid, system): 处理文档类型声明。 name 是文档类型名称。 pubid 是公共标识符。 system 是系统标识符。默认的 TreeBuilder 类中不存在此方法。

2.7 版中的新功能。

19.7.3.6. XMLParser 对象

class xml.etree.ElementTree.XMLParser(html=0, target=None, encoding=None)

Element XML 源数据的结构构建器，基于 expat 解析器。 html 是预定义的 HTML 实体。当前实现不支持此标志。 target 是目标对象。如果省略，构建器将使用标准 TreeBuilder 类的实例。 encoding 1 是可选的。如果给定，该值将覆盖 XML 文件中指定的编码。

close(): 完成向解析器提供数据。返回一个元素结构。

doctype(name, pubid, system): 自 2.7 版起已弃用：在自定义 TreeBuilder 目标上定义 TreeBuilder.doctype() 方法。

feed(data): 将数据提供给解析器。 data 是编码数据。

XMLParser.feed() 为每个开始标签调用 target 的 start() 方法，每个结束标签的 end() 方法和数据由方法data()处理。 XMLParser.close() 调用 target 的方法 close()。 XMLParser 不仅可以用于构建树结构。这是计算 XML 文件最大深度的示例：

>>> from xml.etree.ElementTree import XMLParser
>>> class MaxDepth:                     # The target object of the parser
...     maxDepth = 0
...     depth = 0
...     def start(self, tag, attrib):   # Called for each opening tag.
...         self.depth += 1
...         if self.depth > self.maxDepth:
...             self.maxDepth = self.depth
...     def end(self, tag):             # Called for each closing tag.
...         self.depth -= 1
...     def data(self, data):
...         pass            # We do not need to do anything with data.
...     def close(self):    # Called when all data has been parsed.
...         return self.maxDepth
...
>>> target = MaxDepth()
>>> parser = XMLParser(target=target)
>>> exampleXml = """
... <a>
...   <b>
...   </b>
...   <b>
...     <c>
...       <d>
...       </d>
...     </c>
...   </b>
... </a>"""
>>> parser.feed(exampleXml)
>>> parser.close()
4

脚注

1(1,2,3,4): XML 输出中包含的编码字符串应符合相应的标准。例如，“UTF-8”有效，但“UTF8”无效。参见 https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EncodingDecl 和 https://www.iana.org/assignments/character-sets /character-sets.xhtml。

19.7. xml.etree.ElementTree — ElementTree XML API — Python 文档

目录

19.7. xml.etree.ElementTree — ElementTree XML API

19.7.1. 教程

19.7.1.1. XML 树和元素

19.7.1.2. 解析 XML

19.7.1.3. 寻找有趣的元素

19.7.1.4. 修改 XML 文件

19.7.1.5. 构建 XML 文档

19.7.1.6. 使用命名空间解析 XML

19.7.1.7。其他资源

19.7.2. XPath 支持

19.7.2.1. 例子

19.7.2.2. 支持的 XPath 语法

19.7.3. 参考

19.7.3.1. 职能

19.7.3.2. 元素对象

19.7.3.3. 元素树对象

19.7.3.4. QName 对象

19.7.3.5. TreeBuilder 对象

19.7.3.6. XMLParser 对象

19.7. xml.etree.ElementTree — ElementTree XML API — Python 文档

19.7. xml.etree.ElementTree — ElementTree XML API

19.7.1. 教程

19.7.1.1. XML 树和元素

19.7.1.2. 解析 XML

19.7.1.3. 寻找有趣的元素

19.7.1.4. 修改 XML 文件

19.7.1.5. 构建 XML 文档

19.7.1.6. 使用命名空间解析 XML

19.7.1.7。 其他资源

19.7.2. XPath 支持

19.7.2.1. 例子

19.7.2.2. 支持的 XPath 语法

19.7.3. 参考

19.7.3.1. 职能

19.7.3.2. 元素对象

19.7.3.3. 元素树对象

19.7.3.4. QName 对象

19.7.3.5. TreeBuilder 对象

19.7.3.6. XMLParser 对象

19.7.1.7。其他资源