"xml.etree.ElementTree" ---  ElementTree XML API
************************************************

**源代码：** Lib/xml/etree/ElementTree.py

======================================================================

"xml.etree.ElementTree" 模块实现了一个简单高效的API，用于解析和创建XML
数据。

3.3 版更變: 只要有可能，这个模块将使用快速实现。
"xml.etree.cElementTree" 模块已弃用。

警告:

  "xml.etree.ElementTree" 模块对于恶意构建的数据是不安全的。如果需要解
  析不可信或未经身份验证的数据，请参见 XML 漏洞 。


教程
====

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


XML树和元素
-----------

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


解析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'

備註:

  并非XML输入的所有元素都将作为解析树的元素结束。目前，此模块跳过输入
  中的任何XML注释、处理指令和文档类型声明。然而，使用这个模块的API而不
  是从XML文本解析构建的树可以包含注释和处理指令，生成XML输出时同样包含
  这些注释和处理指令。可以通过将自定义 "TreeBuilder" 实例传递给
  "XMLParser" 构造函数来访问文档类型声明。


Pull API进行非阻塞解析
----------------------

此模块所提供了大多数解析函数都要求在返回任何结果之前一次性读取整个文档
。 可以使用 "XMLParser" 并以渐进方式添加数据，但这是在回调目标上调用方
法的推送式 API。 有时用户真正想要的是能够以渐进方式解析 XML 而无需阻塞
操作，同时享受完整的已构造 "Element" 对象。

针对此需求的最强大工具是 "XMLPullParser"。 它不要求通过阻塞式读取来获
得 XML 数据，而是通过执行 "XMLPullParser.feed()" 调用来渐进式地添加数
据。  要获得已解析的 XML 元素，应调用 "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" 在更简单的用例中使用起来可能并不方便。
如果你不介意你的应用程序在读取 XML 数据时造成阻塞但仍希望具有增量解析
能力，可以考虑 "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()" 找带有特定标签的 *第一个* 子级，然后可以用
"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 ，可以更精确地指定要查找的元素。


修改XML文件
-----------

"ElementTree" 提供了一种构建XML文档并将其写入文件的简单方法。调用
"ElementTree.write()" 方法就可以实现。

创建后可以直接操作 "Element" 对象。例如：使用 "Element.text" 修改文本
字段，使用 "Element.set()" 方法添加和修改属性，以及使用
"Element.append()" 添加新的子元素。

假设我们要为每个国家/地区的中添加一个排名，并在排名元素中添加一个
"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'):
   ...     # using root.findall() to avoid removal during traversal
   ...     rank = int(country.find('rank').text)
   ...     if rank > 50:
   ...         root.remove(country)
   ...
   >>> tree.write('output.xml')

请注意在迭代时进行并发修改可能会导致问题，就像在迭代并修改 Python 列表
或字典时那样。 因此，这个示例先通过 "root.findall()" 收集了所有匹配的
元素，在此之后再对匹配项列表进行迭代。

生成的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()" 函数还提供了一种便捷方法来为给定元素创建新的子元素:

   >>> 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 示例包含两个命名空间，一个具有前缀 "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 示例的一种方式是手动为 "find()" 或 "findall()" 的
xpath 中的每个标记或属性添加 URI:

   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


其他资源
--------

请访问 http://effbot.org/zone/element-index.htm 获取教程和其他文档的链
接。


XPath支持
=========

此模块提供了对 XPath 表达式 的有限支持用于在树中定位元素。 其目标是支
持一个简化语法的较小子集；完整的 XPath 引擎超出了此模块的适用范围。


示例
----

下面是一个演示此模块的部分 XPath 功能的例子。 我们将使用来自 解析 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]")

对于带有命名空间的 XML，应使用通常的限定 "{namespace}tag" 标记法:

   # All dublin-core "title" tags in the document
   root.findall(".//{http://purl.org/dc/elements/1.1/}title")


支持的XPath语法
---------------

+-------------------------+--------------------------------------------------------+
| 语法                    | 含义                                                   |
|=========================|========================================================|
| "tag"                   | 选择具有给定标记的所有子元素。 例如，"spam" 是选择名为 |
|                         | "spam" 的所有子 元素，而 "spam/egg" 是在名为 "spam" 的 |
|                         | 子元素中选择所有名为 "egg" 的孙 元素，"{*}spam" 是在任 |
|                         | 意（或无）命名空间中选择名为 "spam" 的标记，而 "{}*"   |
|                         | 是只选择不在一个命名空间中的标记。  3.8 版更變: 增加了 |
|                         | 对星号通配符的支持。                                   |
+-------------------------+--------------------------------------------------------+
| "*"                     | 选择所有子元素，包括注释和处理说明。例如 "*/egg" 选择  |
|                         | 所有名为 "egg" 的 孙元素。                             |
+-------------------------+--------------------------------------------------------+
| "."                     | 选择当前节点。这在路径的开头非常有用，用于指示它是相对 |
|                         | 路径。                                                 |
+-------------------------+--------------------------------------------------------+
| "//"                    | 选择所有子元素 在当前元素的所有下级中选择所有下级元素  |
|                         | 。 例如，".//egg" 是在整个树中选择所有 "egg" 元素。    |
+-------------------------+--------------------------------------------------------+
| ".."                    | 选择父元素。 如果路径试图前往起始元素的上级（元素的    |
|                         | "find" 被调用）则 返回 "None"。                        |
+-------------------------+--------------------------------------------------------+
| "[@attrib]"             | 选择具有给定属性的所有元素。                           |
+-------------------------+--------------------------------------------------------+
| "[@attrib='value']"     | 选择给定属性具有给定值的所有元素。该值不能包含引号。   |
+-------------------------+--------------------------------------------------------+
| "[tag]"                 | 选择所有包含 "tag" 子元素的元素。只支持直系子元素。    |
+-------------------------+--------------------------------------------------------+
| "[.='text']"            | 选择完整文本内容等于 "text" 的所有元素（包括后代）。   |
|                         | 3.7 版新加入.                                          |
+-------------------------+--------------------------------------------------------+
| "[tag='text']"          | 选择所有包含名为 "tag" 的子元素的元素，这些子元素（包  |
|                         | 括后代）的完整文 本内容等于给定的 "text" 。            |
+-------------------------+--------------------------------------------------------+
| "[position]"            | 选择位于给定位置的所有元素。 位置可以是一个整数 (1 表  |
|                         | 示首位)，表达式 "last()" (表示末位)，或者相对于末位的  |
|                         | 位置 (例如 "last()-1")。                               |
+-------------------------+--------------------------------------------------------+

谓词（方括号内的表达式）之前必须带有标签名称，星号或其他谓词。
"position" 谓词前必须有标签名称。


参考
====


函数
----

xml.etree.ElementTree.canonicalize(xml_data=None, *, out=None, from_file=None, **options)

   C14N 2.0  转换功能。.

   规整化是标准化 XML 输出的一种方式，该方式允许按字节比较和数字签名。
   它降低了 XML 序列化器所具有的自由度并改为生成更受约束的 XML 表示形
   式。 主要限制涉及命名空间声明的位置、属性的顺序和可忽略的空白符等。

   此函数接受一个 XML 数字字符串 (*xml_data*) 或文件路径或者文件类对象
   (*from_file*) 作为输入，将其转换为规整形式，并在提供了 *out* 文件（
   类）对象的情况下将其写到该对象的话，或者如果未提供则将其作为文本字
   符串返回。 输出文件接受文本而非字节数据。  因此它应当以使用 "utf-8"
   编码格式的文本模式来打开。

   典型使用:

      xml_data = "<root>...</root>"
      print(canonicalize(xml_data))

      with open("c14n_output.xml", mode='w', encoding='utf-8') as out_file:
          canonicalize(xml_data, out=out_file)

      with open("c14n_output.xml", mode='w', encoding='utf-8') as out_file:
          canonicalize(from_file="inputfile.xml", out=out_file)

   配置选项 *options* 如下:

   * *with_comments*: 设为真值以包括注释 (默认为假值)

   * *strip_text*: 设为真值以去除文本内容前后的空白符
        （默认值：否）

   * *rewrite_prefixes*: 设为真值以替换带有 "n{number}" 前缀的命名空间
        （默认值：否）

   * *qname_aware_tags*: 一组可感知限定名称的标记名称，其中的前缀
        应当在文本内容中被替换 (默认为空值)

   * *qname_aware_attrs*: 一组可感知限定名称的属性名称，其中的前缀
        应当在文本内容中被替换 (默认为空值)

   * *exclude_attrs*: 一组不应当被序列化的属性名称

   * *exclude_tags*: 一组不应当被序列化的标记名称

   在上面的选项列表中，"一组" 是指任意多项集或包含字符串的可迭代对象，
   排序是不必要的。

   3.8 版新加入.

xml.etree.ElementTree.Comment(text=None)

   注释元素工厂函数。 这个工厂函数可创建一个特殊元素，它将被标准序列化
   器当作 XML 注释来进行序列化。 注释字串可以是字节串或是 Unicode 字符
   串。 *text* 是包含注释字串的字符串。 返回一个表示注释的元素实例。

   请注意 "XMLParser" 会跳过输入中的注释而不会为其创建注释对象。
   "ElementTree" 将只在当使用某个 "Element" 方法向树插入了注释节点时才
   会包含注释节点。

xml.etree.ElementTree.dump(elem)

   将一个元素树或元素结构体写入到 sys.stdout。 此函数应当只被用于调试
   。

   实际输出格式是依赖于具体实现的。 在这个版本中，它将以普通 XML 文件
   的格式写入。

   *elem* 是一个元素树或单独元素。

   3.8 版更變: "dump()" 函数现在会保留用户指定的属性顺序。

xml.etree.ElementTree.fromstring(text, parser=None)

   根据一个字符串常量解析 XML 的节。 与 "XML()" 类似。 *text* 是包含
   XML 数据的字符串。 *parser* 是可选的解析器实例。 如果未给出，则会使
   用标准 "XMLParser"。 返回一个 "Element" 实例。

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

   根据一个字符串片段序列解析 XML 文档。 *sequence* 是包含 XML 数据片
   段的列表或其他序列对象。 *parser* 是可选的解析器实例。 如果未给出，
   则会使用标准的 "XMLParser" 解析器。 返回一个 "Element" 实例。

   3.2 版新加入.

xml.etree.ElementTree.iselement(element)

   检测一个对象是否为有效的元素对象。 *element* 是一个元素实例。 如果
   对象是一个元素对象则返回 "True"。

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

   以增量方式将一个 XML 节解析为元素树，并向用户报告执行情况。
   *source* 是包含 XML 数据的文件名或 *file object*。 *events* 是要报
   告的事件序列。 所支持的事件字符串有 ""start"", ""end"",
   ""comment"", ""pi"", ""start-ns"" 和 ""end-ns"" ("ns" 事件用于获取
   详细的命名空间信息)。 如果 *events* 被省略，则只有 ""end"" 事件会被
   报告。 *parser* 是可选的解析器实例。 如果未给出，则会使用标准的
   "XMLParser" 解析器。 *parser* 必须为 "XMLParser" 的子类并且只能使用
   默认的 "TreeBuilder" 作为目标。 返回一个提供 "(event, elem)" 对的
   *iterator*。

   请注意虽然 "iterparse()" 是以增量方式构建树，但它会对 *source* (或
   其所指定的文件) 发出阻塞式读取。 因此，它不适用于不可执行阻塞式读取
   的应用。 对于完全非阻塞式的解析，请参看 "XMLPullParser"。

   備註:

     "iterparse()" 只会确保当发出 "start" 事件时看到了开始标记的 ">"
     字符，因而在这个点上属性已被定义，但文本容和末尾属性还未被定义。
     这同样适用于元素的下级；它们可能存在也可能不存在。如果你需要已完
     全填充的元素，请改为查找 "end" 事件。

   3.4 版後已棄用: *parser* 参数。

   3.8 版更變: 增加了 "comment" 和 "pi" 事件。

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 内容的字符串。 返回一个表示处理指令的元素实例。

   请注意 "XMLParser" 会跳过输入中的处理指令而不会为其创建注释对象。
   "ElementTree" 将只在当使用某个 "Element" 方法向树插入了处理指令节点
   时才会包含处理指令节点。

xml.etree.ElementTree.register_namespace(prefix, uri)

   注册一个命名空间前缀。 这个注册表是全局的，并且任何对应给定前缀或命
   名空间 URI 的现有映射都会被移除。 *prefix* 是命名空间前缀。 *uri*
   是命名空间 URI。 如果可能的话，这个命名空间中的标记和属性将附带给定
   的前缀来进行序列化。

   3.2 版新加入.

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

   子元素工厂函数。 这个函数会创建一个元素实例，并将其添加到现有的元素
   。

   元素名、属性名和属性值可以是字节串或 Unicode 字符串。 *parent* 是父
   元素。 *tag* 是子元素名。 *attrib* 是一个可选的字典，其中包含元素属
   性。  *extra* 包含额外的属性，以关键字参数形式给出。 返回一个元素实
   例。

xml.etree.ElementTree.tostring(element, encoding="us-ascii", method="xml", *, xml_declaration=None, default_namespace=None, short_empty_elements=True)

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

   3.4 版新加入: *short_empty_elements* 形参。

   3.8 版新加入: *xml_declaration* 和 *default_namespace* 形参。

   3.8 版更變: "tostring()" 函数现在会保留用户指定的属性顺序。

xml.etree.ElementTree.tostringlist(element, encoding="us-ascii", method="xml", *, xml_declaration=None, default_namespace=None, short_empty_elements=True)

   Generates a string representation of an XML element, including all
   subelements.  *element* is an "Element" instance.  *encoding* [1]
   is the output encoding (default is US-ASCII).  Use
   "encoding="unicode"" to generate a Unicode string (otherwise, a
   bytestring is generated).  *method* is either ""xml"", ""html"" or
   ""text"" (default is ""xml""). *xml_declaration*,
   *default_namespace* and *short_empty_elements* has the same meaning
   as in "ElementTree.write()". Returns a list of (optionally) encoded
   strings containing the XML data. It does not guarantee any specific
   sequence, except that "b"".join(tostringlist(element)) ==
   tostring(element)".

   3.2 版新加入.

   3.4 版新加入: *short_empty_elements* 形参。

   3.8 版新加入: *xml_declaration* 和 *default_namespace* 形参。

   3.8 版更變: The "tostringlist()" function now preserves the
   attribute order specified by the user.

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

   Parses an XML section from a string constant.  This function can be
   used to embed "XML literals" in Python code.  *text* is a string
   containing XML data.  *parser* is an optional parser instance.  If
   not given, the standard "XMLParser" parser is used.  Returns an
   "Element" instance.

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

   Parses an XML section from a string constant, and also returns a
   dictionary which maps from element id:s to elements.  *text* is a
   string containing XML data.  *parser* is an optional parser
   instance.  If not given, the standard "XMLParser" parser is used.
   Returns a tuple containing an "Element" instance and a dictionary.


XInclude 支持
=============

This module provides limited support for XInclude directives, via the
"xml.etree.ElementInclude" helper module.  This module can be used to
insert subtrees and text strings into element trees, based on
information in the tree.


示例
----

Here's an example that demonstrates use of the XInclude module. To
include an XML document in the current document, use the
"{http://www.w3.org/2001/XInclude}include" element and set the
**parse** attribute to ""xml"", and use the **href** attribute to
specify the document to include.

   <?xml version="1.0"?>
   <document xmlns:xi="http://www.w3.org/2001/XInclude">
     <xi:include href="source.xml" parse="xml" />
   </document>

By default, the **href** attribute is treated as a file name. You can
use custom loaders to override this behaviour. Also note that the
standard helper does not support XPointer syntax.

To process this file, load it as usual, and pass the root element to
the "xml.etree.ElementTree" module:

   from xml.etree import ElementTree, ElementInclude

   tree = ElementTree.parse("document.xml")
   root = tree.getroot()

   ElementInclude.include(root)

The ElementInclude module replaces the
"{http://www.w3.org/2001/XInclude}include" element with the root
element from the **source.xml** document. The result might look
something like this:

   <document xmlns:xi="http://www.w3.org/2001/XInclude">
     <para>This is a paragraph.</para>
   </document>

If the **parse** attribute is omitted, it defaults to "xml". The href
attribute is required.

To include a text document, use the
"{http://www.w3.org/2001/XInclude}include" element, and set the
**parse** attribute to "text":

   <?xml version="1.0"?>
   <document xmlns:xi="http://www.w3.org/2001/XInclude">
     Copyright (c) <xi:include href="year.txt" parse="text" />.
   </document>

结果可能如下所示：

   <document xmlns:xi="http://www.w3.org/2001/XInclude">
     Copyright (c) 2003.
   </document>


参考
====


函数
----

xml.etree.ElementInclude.default_loader(href, parse, encoding=None)

   Default loader. This default loader reads an included resource from
   disk.  *href* is a URL. *parse* is for parse mode either "xml" or
   "text".  *encoding* is an optional text encoding.  If not given,
   encoding is "utf-8".  Returns the expanded resource.  If the parse
   mode is ""xml"", this is an ElementTree instance.  If the parse
   mode is "text", this is a Unicode string.  If the loader fails, it
   can return None or raise an exception.

xml.etree.ElementInclude.include(elem, loader=None)

   This function expands XInclude directives.  *elem* is the root
   element.  *loader* is an optional resource loader.  If omitted, it
   defaults to "default_loader()". If given, it should be a callable
   that implements the same interface as "default_loader()".  Returns
   the expanded resource.  If the parse mode is ""xml"", this is an
   ElementTree instance.  If the parse mode is "text", this is a
   Unicode string.  If the loader fails, it can return None or raise
   an exception.


元素对象
--------

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

   Element class.  This class defines the Element interface, and
   provides a reference implementation of this interface.

   The element name, attribute names, and attribute values can be
   either bytestrings or Unicode strings.  *tag* is the element name.
   *attrib* is an optional dictionary, containing element attributes.
   *extra* contains additional attributes, given as keyword arguments.

   tag

      一个标识此元素意味着何种数据的字符串(换句话说，元素类型)。

   text
   tail

      These attributes can be used to hold additional data associated
      with the element.  Their values are usually strings but may be
      any application-specific object.  If the element is created from
      an XML file, the *text* attribute holds either the text between
      the element's start tag and its first child or end tag, or
      "None", and the *tail* attribute holds either the text between
      the element's end tag and the next tag, or "None".  For the XML
      data

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

      the *a* element has "None" for both *text* and *tail*
      attributes, the *b* element has *text* ""1"" and *tail* ""4"",
      the *c* element has *text* ""2"" and *tail* "None", and the *d*
      element has *text* "None" and *tail* ""3"".

      To collect the inner text of an element, see "itertext()", for
      example """.join(element.itertext())".

      Applications may store arbitrary objects in these attributes.

   attrib

      A dictionary containing the element's attributes.  Note that
      while the *attrib* value is always a real mutable Python
      dictionary, an ElementTree implementation may choose to use
      another internal representation, and create the dictionary only
      if someone asks for it.  To take advantage of such
      implementations, use the dictionary methods below whenever
      possible.

   The following dictionary-like methods work on the element
   attributes.

   clear()

      Resets an element.  This function removes all subelements,
      clears all attributes, and sets the text and tail attributes to
      "None".

   get(key, default=None)

      Gets the element attribute named *key*.

      Returns the attribute value, or *default* if the attribute was
      not found.

   items()

      Returns the element attributes as a sequence of (name, value)
      pairs.  The attributes are returned in an arbitrary order.

   keys()

      Returns the elements attribute names as a list.  The names are
      returned in an arbitrary order.

   set(key, value)

      Set the attribute *key* on the element to *value*.

   The following methods work on the element's children (subelements).

   append(subelement)

      Adds the element *subelement* to the end of this element's
      internal list of subelements.  Raises "TypeError" if
      *subelement* is not an "Element".

   extend(subelements)

      Appends *subelements* from a sequence object with zero or more
      elements. Raises "TypeError" if a subelement is not an
      "Element".

      3.2 版新加入.

   find(match, namespaces=None)

      Finds the first subelement matching *match*.  *match* may be a
      tag name or a path.  Returns an element instance or "None".
      *namespaces* is an optional mapping from namespace prefix to
      full name.  Pass "''" as prefix to move all unprefixed tag names
      in the expression into the given namespace.

   findall(match, namespaces=None)

      Finds all matching subelements, by tag name or path.  Returns a
      list containing all matching elements in document order.
      *namespaces* is an optional mapping from namespace prefix to
      full name.  Pass "''" as prefix to move all unprefixed tag names
      in the expression into the given namespace.

   findtext(match, default=None, namespaces=None)

      Finds text for the first subelement matching *match*.  *match*
      may be a tag name or a path.  Returns the text content of the
      first matching element, or *default* if no element was found.
      Note that if the matching element has no text content an empty
      string is returned. *namespaces* is an optional mapping from
      namespace prefix to full name.  Pass "''" as prefix to move all
      unprefixed tag names in the expression into the given namespace.

   getchildren()

      Deprecated since version 3.2, will be removed in version 3.9:
      Use "list(elem)" or iteration.

   getiterator(tag=None)

      Deprecated since version 3.2, will be removed in version 3.9:
      Use method "Element.iter()" instead.

   insert(index, subelement)

      Inserts *subelement* at the given position in this element.
      Raises "TypeError" if *subelement* is not an "Element".

   iter(tag=None)

      Creates a tree *iterator* with the current element as the root.
      The iterator iterates over this element and all elements below
      it, in document (depth first) order.  If *tag* is not "None" or
      "'*'", only elements whose tag equals *tag* are returned from
      the iterator.  If the tree structure is modified during
      iteration, the result is undefined.

      3.2 版新加入.

   iterfind(match, namespaces=None)

      Finds all matching subelements, by tag name or path.  Returns an
      iterable yielding all matching elements in document order.
      *namespaces* is an optional mapping from namespace prefix to
      full name.

      3.2 版新加入.

   itertext()

      Creates a text iterator.  The iterator loops over this element
      and all subelements, in document order, and returns all inner
      text.

      3.2 版新加入.

   makeelement(tag, attrib)

      Creates a new element object of the same type as this element.
      Do not call this method, use the "SubElement()" factory function
      instead.

   remove(subelement)

      Removes *subelement* from the element.  Unlike the find* methods
      this method compares elements based on the instance identity,
      not on tag value or contents.

   "Element" objects also support the following sequence type methods
   for working with subelements: "__delitem__()", "__getitem__()",
   "__setitem__()", "__len__()".

   Caution: Elements with no subelements will test as "False".  This
   behavior will change in future versions.  Use specific "len(elem)"
   or "elem is None" test instead.

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

   Prior to Python 3.8, the serialisation order of the XML attributes
   of elements was artificially made predictable by sorting the
   attributes by their name. Based on the now guaranteed ordering of
   dicts, this arbitrary reordering was removed in Python 3.8 to
   preserve the order in which attributes were originally parsed or
   created by user code.

   In general, user code should try not to depend on a specific
   ordering of attributes, given that the XML Information Set
   explicitly excludes the attribute order from conveying information.
   Code should be prepared to deal with any ordering on input. In
   cases where deterministic XML output is required, e.g. for
   cryptographic signing or test data sets, canonical serialisation is
   available with the "canonicalize()" function.

   In cases where canonical output is not applicable but a specific
   attribute order is still desirable on output, code should aim for
   creating the attributes directly in the desired order, to avoid
   perceptual mismatches for readers of the code. In cases where this
   is difficult to achieve, a recipe like the following can be applied
   prior to serialisation to enforce an order independently from the
   Element creation:

      def reorder_attributes(root):
          for el in root.iter():
              attrib = el.attrib
              if len(attrib) > 1:
                  # adjust attribute order, e.g. by sorting
                  attribs = sorted(attrib.items())
                  attrib.clear()
                  attrib.update(attribs)


ElementTree 对象
----------------

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

   ElementTree wrapper class.  This class represents an entire element
   hierarchy, and adds some extra support for serialization to and
   from standard XML.

   *element* is the root element.  The tree is initialized with the
   contents of the XML *file* if given.

   _setroot(element)

      Replaces the root element for this tree.  This discards the
      current contents of the tree, and replaces it with the given
      element.  Use with care.  *element* is an element instance.

   find(match, namespaces=None)

      Same as "Element.find()", starting at the root of the tree.

   findall(match, namespaces=None)

      Same as "Element.findall()", starting at the root of the tree.

   findtext(match, default=None, namespaces=None)

      Same as "Element.findtext()", starting at the root of the tree.

   getiterator(tag=None)

      Deprecated since version 3.2, will be removed in version 3.9:
      Use method "ElementTree.iter()" instead.

   getroot()

      Returns the root element for this tree.

   iter(tag=None)

      Creates and returns a tree iterator for the root element.  The
      iterator loops over all elements in this tree, in section order.
      *tag* is the tag to look for (default is to return all
      elements).

   iterfind(match, namespaces=None)

      Same as "Element.iterfind()", starting at the root of the tree.

      3.2 版新加入.

   parse(source, parser=None)

      Loads an external XML section into this element tree.  *source*
      is a file name or *file object*.  *parser* is an optional parser
      instance. If not given, the standard "XMLParser" parser is used.
      Returns the section root element.

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

      Writes the element tree to a file, as XML.  *file* is a file
      name, or a *file object* opened for writing.  *encoding* [1] is
      the output encoding (default is US-ASCII). *xml_declaration*
      controls if an XML declaration should be added to the file.  Use
      "False" for never, "True" for always, "None" for only if not US-
      ASCII or UTF-8 or Unicode (default is "None").
      *default_namespace* sets the default XML namespace (for
      "xmlns"). *method* is either ""xml"", ""html"" or ""text""
      (default is ""xml""). The keyword-only *short_empty_elements*
      parameter controls the formatting of elements that contain no
      content.  If "True" (the default), they are emitted as a single
      self-closed tag, otherwise they are emitted as a pair of
      start/end tags.

      The output is either a string ("str") or binary ("bytes"). This
      is controlled by the *encoding* argument.  If *encoding* is
      ""unicode"", the output is a string; otherwise, it's binary.
      Note that this may conflict with the type of *file* if it's an
      open *file object*; make sure you do not try to write a string
      to a binary stream and vice versa.

      3.4 版新加入: *short_empty_elements* 形参。

      3.8 版更變: The "write()" method now preserves the attribute
      order specified by the user.

This is the XML file that is going to be manipulated:

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

Example of changing the attribute "target" of every link in first
paragraph:

   >>> 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 wrapper.  This can be used to wrap a QName attribute value,
   in order to get proper namespace handling on output.  *text_or_uri*
   is a string containing the QName value, in the form {uri}local, or,
   if the tag argument is given, the URI part of a QName.  If *tag* is
   given, the first argument is interpreted as a URI, and this
   argument is interpreted as a local name. "QName" instances are
   opaque.


TreeBuilder Objects
-------------------

class xml.etree.ElementTree.TreeBuilder(element_factory=None, *, comment_factory=None, pi_factory=None, insert_comments=False, insert_pis=False)

   Generic element structure builder.  This builder converts a
   sequence of start, data, end, comment and pi method calls to a
   well-formed element structure.  You can use this class to build an
   element structure using a custom XML parser, or a parser for some
   other XML-like format.

   *element_factory*, when given, must be a callable accepting two
   positional arguments: a tag and a dict of attributes.  It is
   expected to return a new element instance.

   The *comment_factory* and *pi_factory* functions, when given,
   should behave like the "Comment()" and "ProcessingInstruction()"
   functions to create comments and processing instructions.  When not
   given, the default factories will be used.  When *insert_comments*
   and/or *insert_pis* is true, comments/pis will be inserted into the
   tree if they appear within the root element (but not outside of
   it).

   close()

      Flushes the builder buffers, and returns the toplevel document
      element.  Returns an "Element" instance.

   data(data)

      Adds text to the current element.  *data* is a string.  This
      should be either a bytestring, or a Unicode string.

   end(tag)

      Closes the current element.  *tag* is the element name.  Returns
      the closed element.

   start(tag, attrs)

      Opens a new element.  *tag* is the element name.  *attrs* is a
      dictionary containing element attributes.  Returns the opened
      element.

   comment(text)

      Creates a comment with the given *text*.  If "insert_comments"
      is true, this will also add it to the tree.

      3.8 版新加入.

   pi(target, text)

      Creates a comment with the given *target* name and *text*.  If
      "insert_pis" is true, this will also add it to the tree.

      3.8 版新加入.

   In addition, a custom "TreeBuilder" object can provide the
   following methods:

   doctype(name, pubid, system)

      Handles a doctype declaration.  *name* is the doctype name.
      *pubid* is the public identifier.  *system* is the system
      identifier.  This method does not exist on the default
      "TreeBuilder" class.

      3.2 版新加入.

   start_ns(prefix, uri)

      Is called whenever the parser encounters a new namespace
      declaration, before the "start()" callback for the opening
      element that defines it. *prefix* is "''" for the default
      namespace and the declared namespace prefix name otherwise.
      *uri* is the namespace URI.

      3.8 版新加入.

   end_ns(prefix)

      Is called after the "end()" callback of an element that declared
      a namespace prefix mapping, with the name of the *prefix* that
      went out of scope.

      3.8 版新加入.

class xml.etree.ElementTree.C14NWriterTarget(write, *, with_comments=False, strip_text=False, rewrite_prefixes=False, qname_aware_tags=None, qname_aware_attrs=None, exclude_attrs=None, exclude_tags=None)

   A C14N 2.0 writer.  Arguments are the same as for the
   "canonicalize()" function.  This class does not build a tree but
   translates the callback events directly into a serialised form
   using the *write* function.

   3.8 版新加入.


XMLParser对象
-------------

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

   This class is the low-level building block of the module.  It uses
   "xml.parsers.expat" for efficient, event-based parsing of XML.  It
   can be fed XML data incrementally with the "feed()" method, and
   parsing events are translated to a push API - by invoking callbacks
   on the *target* object.  If *target* is omitted, the standard
   "TreeBuilder" is used. If *encoding* [1] is given, the value
   overrides the encoding specified in the XML file.

   3.8 版更變: Parameters are now keyword-only. The *html* argument no
   longer supported.

   close()

      Finishes feeding data to the parser.  Returns the result of
      calling the "close()" method of the *target* passed during
      construction; by default, this is the toplevel document element.

   feed(data)

      Feeds data to the parser.  *data* is encoded data.

   "XMLParser.feed()" calls *target*'s "start(tag, attrs_dict)" method
   for each opening tag, its "end(tag)" method for each closing tag,
   and data is processed by method "data(data)".  For further
   supported callback methods, see the "TreeBuilder" class.
   "XMLParser.close()" calls *target*'s method "close()". "XMLParser"
   can be used not only for building a tree structure. This is an
   example of counting the maximum depth of an XML file:

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

class xml.etree.ElementTree.XMLPullParser(events=None)

   A pull parser suitable for non-blocking applications.  Its input-
   side API is similar to that of "XMLParser", but instead of pushing
   calls to a callback target, "XMLPullParser" collects an internal
   list of parsing events and lets the user read from it. *events* is
   a sequence of events to report back.  The supported events are the
   strings ""start"", ""end"", ""comment"", ""pi"", ""start-ns"" and
   ""end-ns"" (the "ns" events are used to get detailed namespace
   information).  If *events* is omitted, only ""end"" events are
   reported.

   feed(data)

      Feed the given bytes data to the parser.

   close()

      Signal the parser that the data stream is terminated. Unlike
      "XMLParser.close()", this method always returns "None". Any
      events not yet retrieved when the parser is closed can still be
      read with "read_events()".

   read_events()

      Return an iterator over the events which have been encountered
      in the data fed to the parser.  The iterator yields "(event,
      elem)" pairs, where *event* is a string representing the type of
      event (e.g. ""end"") and *elem* is the encountered "Element"
      object, or other context value as follows.

      * "start", "end": the current Element.

      * "comment", "pi": the current comment / processing instruction

      * "start-ns": a tuple "(prefix, uri)" naming the declared
        namespace mapping.

      * "end-ns": "None" (this may change in a future version)

      Events provided in a previous call to "read_events()" will not
      be yielded again.  Events are consumed from the internal queue
      only when they are retrieved from the iterator, so multiple
      readers iterating in parallel over iterators obtained from
      "read_events()" will have unpredictable results.

   備註:

     "XMLPullParser" only guarantees that it has seen the ">"
     character of a starting tag when it emits a "start" event, so the
     attributes are defined, but the contents of the text and tail
     attributes are undefined at that point.  The same applies to the
     element children; they may or may not be present.如果你需要已完全
     填充的元素，请改为查找 "end" 事件。

   3.4 版新加入.

   3.8 版更變: 增加了 "comment" 和 "pi" 事件。


异常
----

class xml.etree.ElementTree.ParseError

   XML parse error, raised by the various parsing methods in this
   module when parsing fails.  The string representation of an
   instance of this exception will contain a user-friendly error
   message.  In addition, it will have the following attributes
   available:

   code

      A numeric error code from the expat parser. See the
      documentation of "xml.parsers.expat" for the list of error codes
      and their meanings.

   position

      A tuple of *line*, *column* numbers, specifying where the error
      occurred.

-[ 註解 ]-

[1] 包括在 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。
