XML树和元素

XML是一种固有的分层数据格式，最自然的表示方式是树。ET为此目的有两个类 – ElementTree将整个XML文档表示为树，并且Element表示此树中的单个节点。与整个文档的交互（读取和写入文件）通常在ElementTree级别完成。与单个XML元素及其子元素的交互在Element level.

解析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 ETtree = 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"

Pull API进行非阻塞解析来访问文档类型声明

提供的大多数解析函数通过此模块要求在返回任何结果之前立即读取整个文档。可以使用XMLParser并逐步向其中提供数据，但它是一个推送API，用于调用回调目标上的方法，这种方法太低级且不便于formost。有时用户真正想要的是能够在不阻塞操作的情况下逐步解析XML，同时享受构造的便利Element对象

最强大的工具是XMLPullParser。它不需要阻塞读取来获取XML数据，而是通过XMLPullParser.feed()调用来进行数据递增。要获取解析的XMLelements，请调用XMLPullParser.read_events()。下面是一个示例：

>>> parser = ET.XMLPullParser(["start", "end"])>>> parser.feed("<mytag>sometext")>>> list(parser.read_events())[("start", <Element "mytag" at 0x7fa66db2be58>)]>>> parser.feed(" more text</mytag>")>>> for event, elem in parser.read_events():...     print(event)...     print(elem.tag, "text=", elem.text)...end

明显的用例是以非阻塞方式运行的应用程序，其中XML数据是从套接字接收或从某些存储设备逐步读取的。在这种情况下，阻塞读取是不可接受的.

因为它是如此灵活，XMLPullParser使用更简单的用例可能不方便。如果您不介意您的应用程序阻止读取XMLdata但仍希望具有增量解析功能，请查看iterparse()。当你正在阅读一个大的XML文档并且不想将它完全保存在内存中时它会很有用.

找到有趣的元素

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 child，Element.text访问元素的textcontent。Element.get()访问元素的属性：

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

使用 XPath .

修改XML文件//可以查找要查找的元素的更复杂的说明

ElementTree提供了一种构建XML文档并将其写入文件的简单方法.ElementTree.write()方法就是为了达到这个目的.

一旦创建，Element对象可以直接操作改变字段（如Element.text），添加和修改属性（Element.set()方法），以及添加新的子句（例如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>

构建XML文档

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

>>> 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>

使用命名空间解析XML

如果XML输入有名称空间，带有prefix:sometag形式前缀的标签和属性扩展到{uri}sometag，其中prefix被完整的URI。另外，如果有一个默认的命名空间，那个完整的URI会被添加到所有非前缀的标签上.

这是一个包含两个名称空间的XML示例，一个名称前缀为“虚构”，另一个名称作为默认名称空间：

<?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示例的一种方法是手动将URL添加到find()要么 findall()：

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 LeachEric Idle |--> Sir Robin |--> Gunther |--> Commander Clement

其他资源

请参阅http://effbot.org/zone/element-index.htm获取教程和指向otherdocs的链接.

例

这是一个演示模块的一些XPath功能的示例。我们将使用countrydata来自的XML文档解析XML 部分：

import xml.etree.ElementTree as ETroot = ET.fromstring(countrydata)# Top-level elementsroot.findall(".")# All "neighbor" grand-children of "country" children of the top-level# elementsroot.findall("./country/neighbor")# Nodes with name="Singapore" that have a "year" childroot.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 parentroot.findall(".//neighbor[2]")

支持的XPath语法

谓词（方括号内的表达式）必须以标记名，星号或其他谓词开头。position谓语必须以标签名称为前提.

(

xml.etree.ElementTree.Comment)text=None评论要素厂。此工厂函数创建一个特殊元素，它将被标准序列化程序序列化为XML注释。注释字符串可以是bytestring或Unicode字符串。

是包含注释字符串的astring。返回表示注释的元素实例.text注意

跳过输入中的注释，而不是为它们创建注释对象。如果XMLParser使用ElementTree方法中的一个插入到树中，Element将只包含注释节点

xml.etree.ElementTree.dump// (elem）

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

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

elem是元素树或单个元素.

xml.etree.ElementTree.fromstring (text)

从字符串常量中解析XML部分。与XML(). text相同的是包含XML数据的字符串。返回Element instance.

xml.etree.ElementTree.fromstringlist (sequence, parser=None)

从一系列字符串片段中解析XML文档。sequence是alist或包含XML数据片段的其他序列。parser是anoptional解析器实例。如果没有给出，则使用标准的XMLParser解析器。返回Element instance.

新版本3.2.

xml.etree.ElementTree.iselement (element)

检查对象是否有效元素对象。element是一个例子。如果这是一个元素对象，则返回一个真值.

xml.etree.ElementTree.iterparse(source, events=None, parser=None)

逐步将XML部分分解为一个元素树，然后向用户报告。source是包含XML数据的文件名或文件对象。events是一系列要报告的事件。支持的事件是字符串"start", "end", "start-ns"和"end-ns"（“ns”事件用于获取详细的命名空间信息）。如果events省略，只报告"end"事件.parser是一个可选的解析器实例。如果没有给出，则使用标准的XMLParser解析器。parser必须是XMLParser的子类，并且只能使用默认的TreeBuilder作为atarget。返回迭代器提供(event, elem)对.

注意，当iterparse()逐步构建树时，它会发出阻塞读取source（或它命名的文件）。因此，它不适用于无法进行阻塞读取的应用程序。对于完全非阻塞的分析，请参阅XMLPullParser.

注意

iterparse()仅保证在发出“start”事件时看到了标签的“＆gt;”字符，因此定义了属性，但是在该点处未定义text和tail属性的内容。这同样适用于儿童元素;他们可能会或可能不会出现.

如果您需要一个完全填充的元素，请寻找“结束”事件.

自版本3.4以后删除： parser argument.

xml.etree.ElementTree.parse (source, parser=None )

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

xml.etree.ElementTree.ProcessingInstruction (target, text=None）

元素工厂。此工厂函数创建一个特殊元素，该元素将被序列化为XML处理指令。target是包含PI目标的字符串。text是一个包含PI内容的字符串，ifgiven。返回一个表示处理指令的元素实例.

注意XMLParser跳过输入中的处理指令而不是为它们创建注释对象。一个ElementTree只包含处理指令节点，如果它们已经使用Element方法之一插入树中

xml.etree.ElementTree.register_namespace// (prefix, uri）

注册名称空间前缀。注册表是全局的，并且将删除给定前缀或命名空间URI的任何现有映射.prefix是名称空间前缀。uri是名称空间uri。如果可能的话，这个命名空间中的标签和属性将使用给定的前缀序列化.

新版本3.2.

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

Sublement factory。此函数创建一个元素实例，并附加到现有元素.

元素名称，属性名称和属性值可以是字符串或Unicode字符串。parent是父元素。tag是子元素名称。attrib是一个可选字典，包含elementattributes。extra包含其他属性，以keywordarguments的形式给出。返回一个元素实例.

xml.etree.ElementTree.tostring (element, encoding=”us-ascii”, method=”xml”, *, short_empty_elements=True)

生成一个XML元素的字符串表示，包括所有元素。element是一个Element实例。encoding [1]是输出编码（默认为US-ASCII）。使用encoding="unicode"生成Unicode字符串（否则，生成字节串）。method是"xml", "html"或"text"（默认是"xml").short_empty_elements与ElementTree.write()。返回包含XML数据的（可选）编码字符串.

版本3.4： short_empty_elements参数

xml.etree.ElementTree.tostringlist//(element, encoding=”us-ascii”, method=”xml”, *, short_empty_elements=True）

生成XML元素的字符串表示形式，包括所有元素。element是一个Element实例。encoding [1]是输出编码（默认为US-ASCII）。使用encoding="unicode"生成Unicode字符串（否则，生成字节串）。method是"xml", "html"或"text"（默认是"xml").short_empty_elements与ElementTree.write()中的含义相同。返回包含XML数据的（可选）编码字符串列表。它不保证任何特定的序列，除了b"".join(tostringlist(element)) == tostring(element).

版本3.2中的新增.

版本3.4： short_empty_elements参数

xml.etree.ElementTree.XML// (text, parser=None)

从字符串常量中获取XML部分。此函数可用于在Python代码中嵌入“XML文字”。text是一个包含XMLdata的字符串。parser是一个可选的解析器实例。如果没有给出，则使用标准的XMLParser解析器。返回Element实例

xml.etree.ElementTree.XMLID// (text, parser=None)

从字符串常量解析XML部分，并返回从元素id：s映射到元素的字典。text是一个包含XMLdata的字符串。parser是一个可选的解析器实例。如果没有给出，则使用标准的XMLParser解析器。返回一个包含Element实例和字典的元组.

元素对象

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元素None为text和tail属性，b元素有text "1"和tail "4"，c元素有text "2"和tail None，而d元素有text None和tail "3".

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

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

attrib

包含元素属性的字典。注意，而attribvalue始终是一个真正可变的Python字典，ElementTreeimplementation可以选择使用另一个内部表示，并且只有在有人要求时才创建字典。要利用这些实现，尽可能使用下面的字典方法.

以下类似字典的方法处理元素属性.

clear ()

重置元素。此函数删除所有子元素，清除allattributes，并将text和tail属性设置为None.

get（key, default=None）

获取名为key.

的元素属性返回属性值，或default如果找不到属性.

items（)

将元素属性作为（名称，值）的序列返回对。属性以任意顺序返回.

keys ()

将元素属性名称作为列表返回。名称以任意顺序返回.

set (key, value)

将元素key设置为元素value.

以下方法处理元素的子元素（子元素）.

append（subelement）

将元素subelement添加到元素内部子元素列表的末尾。如果TypeError提高subelement不是Element.

extend（subelements）

从零个或多个元素的序列对象中追加subelements。如果是子元素，则返回TypeError不是Element.

版本3.2.

find(match, namespaces=None)

找到匹配的第一个子元素match. match可以是标签名称或路径。返回一个元素实例或None. namespaces是从命名空间前缀到全名的可选映射.

findall (match, namespaces=None )

按标签名称或路径查找所有匹配的子元素。返回包含文档顺序中所有匹配元素的列表。namespaces是从名称空间前缀到全名的可选映射.

findtext（match, default=None, namespaces=None）

找到匹配的第一个子元素的文本match. match可以是标签名称或路径。返回第一个匹配元素的文本内容，或default如果没有找到元素。注意如果匹配元素没有文本内容，则返回空字符串。namespaces是从命名空间前缀到全名的可选映射.

getchildren (）

从版本3.2开始不推荐使用：使用list(elem)或者迭代.

getiterator (tag=None)

自版本3.2以后删除：使用方法Element.iter()代替

insert (index, subelement)

插入subelement在这个元素的给定位置。引发TypeError如果subelement不是Element.

iter（tag=None）

创建一棵树迭代器使用当前元素作为根。迭代器遍历此元素及其下面的所有元素，indocument（深度优先）顺序。如果tag不是None或"*"，只从迭代器返回标签等于tag的元素。如果在迭代过程中修改了树结构，结果是不确定的.

新版本3.2.

iterfind (match, namespaces=None)

按标签名称或路径查找所有匹配的子元素。返回以文档顺序生成所有匹配元素的可迭代元素。namespaces是从命名空间前缀到全名的可选映射.

新版本3.2.

itertext ()

创建一个文本迭代器。迭代器按文档顺序循环遍历此元素和allsubelements，并返回所有内部文本.

新版本3.2.

makeelement (tag, attrib)

创建与此元素具有相同类型的新元素对象。不要这个方法，请改用SubElement()工厂功能.

remove (subelement)

从元素中取出subelement。与find *方法不同，thismethod基于实例标识而不是标签值或内容来比较元素.

Element对象也支持以下序列类型方法来处理子元素：__delitem__(),__getitem__(), __setitem__(),__len__().

注意：没有子元素的元素将测试为False。此行为将在未来版本中更改。使用具体的len(elem)或elem isNone测试.

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")

元素树对象

class xml.etree.ElementTree.ElementTree（element=None, file=None）

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

element是根元素。用XML file的内容初始化树，如果给出的话

_setroot// (element)

替换此树的根元素。这会丢弃树的当前内容，并将其替换为给定元素。使用withcare。element是元素实例.

find (match, namespaces=None )

与…一样 Element.find()，从树根开始.

findall（match, namespaces=None）

与…一样 Element.findall()，从树根开始.

findtext（match, default=None, namespaces=None）

与…一样 Element.findtext()，从树根开始.

getiterator（tag=None）

从版本3.2开始不推荐使用：使用方法ElementTree.iter()代替。

getroot（）

返回此树的根元素.

iter（tag=None）

创建并返回根元素的树迭代器。iterator循环遍历此树中的所有元素，按部分顺序排列。tag是tagto查找（默认是返回所有元素）.

iterfind（match, namespaces=None）

与Element.iterfind()相同，从树的根开始.

新版本3.2.

parse (source, parser=None)

将外部XML部分载入此元素树。source是一个文件名或文件对象. parser是一个可选的解析器实例。如果没有给出，则使用标准的XMLParser解析器。返回thisction根元素.

write（file, encoding=”us-ascii”, xml_declaration=None, default_namespace=None, method=”xml”, *, short_empty_elements=True)

将元素树写成文件，如XML。file是一个文件名，或文件对象打开写入。encoding [1]是outputencoding（默认为US-ASCII）.xml_declaration控制是否应该在文件中添加XML声明。使用False表示永远，True表示总是，None仅适用于US-ASCII或UTF-8或Unicode（默认为None).default_namespace设置默认的XML命名空间（对于“xmlns”）。method是"xml", "html"或"text"（默认为"xml"）。keyword-only short_empty_elements参数控制不包含内容的元素的格式。如果True（默认值），它们作为单个自闭标签发送，否则它们作为一对开始/结束标签发出.

输出是字符串（str）或二进制（bytes)。这是由encoding论点控制的。如果encoding是"unicode"，则输出为字符串;否则，它是二进制的。请注意，这可能与file的类型冲突，如果它是一个打开的文件对象;确保你没有尝试将字符串写入abinary流，反之亦然.

版本3.4： short_empty_elements参数

这个是要操作的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>

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

>>> 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")

QName Objects

class xml.etree.ElementTree.QName（text_or_uri, tag=None）

QName包装器。这可以用于包装QName属性值，以便在输出上获得适当的命名空间处理。text_or_uri是一个包含QName值的字符串，格式为{uri} local，或者，如果给出了tag参数，则为QName的URI部分。如果tag给出，第一个参数被解释为一个URI，这个参数被解释为一个本地名称.QName实例是不透明的.

TreeBuilder Objects

class xml.etree.ElementTree.TreeBuilder（element_factory=None）

通用元素结构构建器。此构建器将一系列开始，数据和结束方法调用转换为格式良好的元素结构。您可以使用此类使用自定义XML解析器构建元素结构，或者使用其他类似XML格式的解析器。element_factory，当给出时，必须是一个可调用的接受两个位置参数：一个标签和一个属性的字典。期望返回一个新的元素实例.

close ()

刷新构建器缓冲区，并返回toplevel documentelement。返回Element instance.

data (data)

将文本添加到当前元素。data是一个字符串。这应该是一个字节串或一个Unicode字符串.

end (tag)

关闭当前元素。tag是元素名称。返回关闭元素.

start (tag, attrs )

打开一个新元素。tag是元素名称。attrs是包含元素属性的字典。返回打开的元素.

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

doctype（name, pubid, system）

处理一个doctype声明。name是doctype名称。pubid是公共标识符。system是系统标识符。这个方法不存在于默认的TreeBuilder class.

新版本3.2.

XMLParser Objects

class xml.etree.ElementTree.XMLParser（html=0, target=None, encoding=None）

这个类是模块的低级构建块。它使用xml.parsers.expat进行有效的，基于事件的XML解析。它可以使用feed()方法递增地提供XML数据，并且通过在target对象上调用回调将parsingvents转换为推送API。如果省略target，则使用标准TreeBuilder。html参数历史上用于向后兼容，现在已弃用。如果给出encoding [1]，则该值将覆盖XML文件中指定的编码.

自版本3.4以后删除： html论点。其余的参数应该通过关键字传递，以准备删除html论证

close// ()

完成向解析器提供数据。返回调用close()在构造过程中传递的target方法的结果;默认情况下，这是顶级文档元素.

doctype (name, pubid, system )

从版本3.2开始不推荐使用：在自定义的TreeBuildertarget上定义TreeBuilder.doctype()方法

feed// (data)

将数据提供给解析器。data是编码数据

XMLParser.feed()来电target的start(tag, attrs_dict)每个开始标签的方法，每个结束标签的end(tag)方法，数据用方法处理data(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

XMLPullParser Objects

class xml.etree.ElementTree.XMLPullParser（events=None）

适用于非阻塞应用程序的pull解析器。它的输入端API类似于XMLParser，但不是将调用推送到acallback目标，XMLPullParser收集parsingevents的内部列表，并让用户从中读取。events是一系列报道的事件。支持的事件是字符串"start", "end","start-ns"和"end-ns"（“ns”事件用于获取详细名称空间信息）。如果events省略，只"end"事件报道了

feed（data）

将给定的字节数据提供给解析器.

close（）

向解析器发出数据流终止的信号。不像XMLParser.close()，这个方法总是返回None。解析器关闭时尚未检索到的任何事件仍然可以用read_events().

read_events（）

返回迭代器，该迭代器覆盖了在传递给分析器的数据中遇到的事件。迭代器产生(event, elem)对，其中event是表示事件类型的astring（例如"end"）和elem已经被攻击了Element object.

之前致电read_events()将不会再次受到影响。只有从迭代器中检索到事件才会从内部队列中消耗事件，因此多个读取器在从read_events()会有不可预知的结果.

注意

XMLPullParser只保证它在发出“start”事件时看到了起始标记的“＆gt;”字符，因此定义了属性，但是文本和尾部属性的内容在此时未定义。这同样适用于儿童元素;它们可能存在也可能不存在.

如果你需要一个完全填充的元素，请寻找“结束”事件.

新版本3.4.

例外

class xml.etree.ElementTree.ParseError

解析失败时，由此模块中的各种解析方法引发的XML解析错误。此异常的实例的字符串表示形式包含用户友好的错误消息。此外，它还具有以下属性：

code

来自expat解析器的数字错误代码。参见xml.parsers.expat对于错误代码列表及其含义.

position

line, column数字的元组，指出错误发生的位置.

脚注