python xml 增加子节点 python xml.etree

文章目录

• 1.XML 树和元素
• 2.解析 XML
• 3.非阻塞解析API
• 4.元素查找
• 5.修改 XML 文件
• 6.构建 XML 文档
• 7.使用命名空间解析 XML
• 8.XPath 支持

• 8.1.简单范例
• 8.2.支持的 XPath 语法

• 9.函数

• 9.1.ElementTree
• 9.2.Element

• 9.2.1属性参数
• 9.2.2方法

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

1.XML 树和元素

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

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'

注意：并非 XML 输入的所有元素最终都会成为解析树的元素。目前，该模块跳过输入中的任何 XML 注释、处理指令和文档类型声明。然而，使用该模块的 API 而非从 XML 文本解析构建的树可以在其中包含注释和处理指令；它们将在生成 XML 输出时包含在内。可以通过将自定义TreeBuilder实例传递给XMLParser 构造函数来访问文档类型声明。

3.非阻塞解析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 文档并且不想将其完全保存在内存中时，它会很有用。

4.元素查找

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

5.修改 XML 文件

ElementTree提供了一种简单的方法来构建 XML 文档并将它们写入文件。该ElementTree.write()方法用于此目的。一旦创建，Element可以通过直接更改其字段（例如Element.text）、添加和修改属性（Element.set()方法）以及添加新子项（例如 with Element.append()）来操作对象。假设我们要为每个国家的排名添加一个，并updated 为 rank 元素添加一个属性：

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

6.构建 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>

7.使用命名空间解析 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

8.XPath 支持

8.1.简单范例

该模块为在树中定位元素的XPath 表达式提供了有限的支持 。目标是支持缩写语法的一小部分；完整的 XPath 引擎超出了模块的范围。这是一个演示模块的一些 XPath 功能的示例 ：

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

8.2.支持的 XPath 语法

句法	意义
tag	选择具有给定标签的所有子元素。例如，spam选择所有名为 的子元素spam，并选择所有名为的 子元素中的spam/egg所有孙子元素。 选择给定命名空间中的所有标签，选择 在任何（或没有）命名空间中命名的 标签，并且只选择不在命名空间中的标签。eggspam{namespace}{}spamspam{}*在 3.8 版更改:添加了对星形通配符的支持。
*	选择所有子元素，包括注释和处理指令。例如，*/egg 选择所有名为egg.
.	选择当前节点。这在路径的开头最有用，表明它是相对路径。
//	选择当前元素下方所有级别上的所有子元素。例如，.//egg选择egg整个树中的所有元素。
…	选择父元素。None如果路径试图到达起始元素的祖先（该元素find被调用），则返回。
[@attrib]	选择具有给定属性的所有元素。
[@attrib=‘value’]	选择给定属性具有给定值的所有元素。该值不能包含引号。
[tag]	选择所有具有名为的子元素的元素 tag。仅支持直系子女。
[.=‘text’]	选择其完整文本内容（包括后代）等于给定的所有元素text。3.7 版中的新功能。
[tag=‘text’]	选择所有具有子元素的元素，该子元素 tag的完整文本内容（包括后代）等于给定的text.
[position]	选择位于给定位置的所有元素。位置可以是整数（1 是第一个位置）、表达式last() （最后一个位置）或相对于最后一个位置的位置（例如last()-1）。

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

9.函数

9.1.ElementTree

**1.xml.etree.ElementTree.canonicalize( xml_data=None , * , out=None , from_file=None , options )
规范化是一种以允许逐字节比较和数字签名的方式规范化 XML 输出的方法。它降低了 XML 序列化程序的自由度，而是生成了更受约束的 XML 表示。主要限制涉及命名空间声明的放置、属性的顺序和可忽略的空格。
此函数将 XML 数据字符串 ( xml_data ) 或文件路径或类似文件的对象 ( from_file ) 作为输入，将其转换为规范形式，并使用out file(-like) 对象（如果提供）将其写出，或者如果不是，则将其作为文本字符串返回。输出文件接收文本，而不是字节。因此，它应该以带有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)

配置选项如下：
with_comments：设置为 true 以包含评论（默认值：false）
strip_text：设置为 true 以在文本内容之前和之后去除空格。（默认：假）
rewrite_prefixes：设置为 true 以将命名空间前缀替换为“n{number}”。（默认：假）
qname_aware_tags：一组 qname 感知标签名称，其中前缀应在文本内容中替换（默认：空）
qname_aware_attrs：一组 qname 感知属性名称，其中前缀应在文本内容中替换（默认：空）
exclude_attrs：一组不应序列化的属性名称
exclude_tags：一组不应序列化的标签名称
在上面的选项列表中，“a set”指的是任何字符串的集合或可迭代，不需要排序。
3.8 版中的新功能。

2.xml.etree.ElementTree.Comment(text=None)
此工厂函数创建一个特殊元素，该元素将由标准序列化程序序列化为 XML 注释。注释字符串可以是字节字符串或 Unicode 字符串。 text是一个包含注释字符串的字符串。返回表示评论的元素实例。请注意，XMLParser跳过输入中的注释，而不是为它们创建注释对象。只有使用其中一种方法ElementTree将注释节点插入到树中时，它们才会包含注释节点Element。

3.xml.etree.ElementTree.dump(elem)
将元素树或元素结构写入 sys.stdout。此功能应仅用于调试。确切的输出格式取决于实现。在这个版本中，它被编写为一个普通的 XML 文件。elem是元素树或单个元素。在 3.8 版更改:该dump()函数现在保留用户指定的属性顺序。

4.xml.etree.ElementTree.fromstring(text, parser=None)
从字符串常量解析 XML 部分。与XML()相同。 text 是一个包含 XML 数据的字符串。 parser是一个可选的解析器实例。如果未给出，XMLParser则使用标准解析器。返回一个Element实例。

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

6.xml.etree.ElementTree.iselement(element)
检查一个对象是否看起来是一个有效的元素对象。 element是一个元素实例。True如果这是一个元素对象，则返回。

7.xml.etree.ElementTree.iterparse(source, events=None, parser=None)
将XML部分逐步解析为元素树，并向用户报告正在发生的事情。 source是 包含 XML 数据的文件名或文件对象。events是要报告的一系列事件。支持特定的字符串"start", “end”, “comment”, “pi”, “start-ns” 和 “end-ns”（"ns"事件用于获取详细的命名空间信息）。如果省略 events，则仅end事件支持。 parser是一个可选的解析器实例。如果未给出， 则使用标准解析器。 parser必须是一个子类， 并且只能使用默认值TreeBuilder作为目标。返回一个迭代器提供(event, elem)。请注意，虽然iterparse()以增量方式构建树，但它会阻止对源（或其命名的文件）的读取。因此，它不适合无法进行阻塞读取的应用程序。有关完全非阻塞解析，请参阅XMLPullParser。

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

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

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

**11. xml.etree.ElementTree.SubElement(parent, tag, attrib={}, extra)
子元素工厂。此函数创建一个元素实例，并将其附加到现有元素。元素名称、属性名称和属性值可以是字节字符串或 Unicode 字符串。 parent是父元素。 tag是子元素名称。 attrib是一个可选字典，包含元素属性。 extra包含附加属性，作为关键字参数给出。返回一个元素实例。

12. xml.etree.ElementTree.tostring

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

生成 XML 元素的字符串表示形式，包括所有子元素。 元素是一个Element实例。 encoding 1是输出编码（默认为 US-ASCII）。用于encoding=“unicode"生成 Unicode 字符串（否则会生成字节串）。 方法 是"xml”,“html"或"text”（默认为"xml"）。 xml_declaration、default_namespace和short_empty_elements与 中的含义相同ElementTree.write()。返回包含 XML 数据的（可选）编码字符串。

13. xml.etree.ElementTree.tostringlist

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

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

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

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

9.2.Element

**1.class xml.etree.ElementTree.Element(tag, attrib={}, extra)
元素类。该类定义了 Element 接口，并提供了该接口的参考实现。元素名称、属性名称和属性值可以是字节字符串或 Unicode 字符串。 tag是元素名称。 attrib是一个可选字典，包含元素属性。 extra包含附加属性，作为关键字参数给出。

9.2.1属性参数

名称	解释
tag	一个字符串，用于标识此元素表示的数据类型（换句话说，元素类型）。
text	标签包含的文本
tail	这些属性可用于保存与元素关联的附加数据。它们的值通常是字符串，但也可以是任何特定于应用程序的对象。如果元素是从 XML 文件创建的，则text属性保存元素的开始标记和它的第一个子标记或结束标记之间的文本，或者None，tail属性保存元素的结束标记和下一个标记之间的文本，或None。对于 XML 数据
attrib	包含元素属性的字典。请注意，虽然 attrib值始终是一个真正的可变 Python 字典，但 ElementTree 实现可能会选择使用另一种内部表示，并且仅在有人要求时才创建字典。要利用此类实现，请尽可能使用以下字典方法。

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

9.2.2方法

名称	解释
clear()
get(key, default=None)	获取名为key的元素属性。返回属性值，如果未找到该属性，则返回默认值。
items()	将元素属性作为 (name, value) 对的序列返回。属性以任意顺序返回。
keys()	将元素属性名称作为列表返回。名称以任意顺序返回。
set(key, value)	将元素上的属性键设置为value。
append(subelement)	将元素子元素添加到此元素的内部子元素列表的末尾。TypeError如果subelement不是 则 引发Element。
extend(subelements)	附加来自具有零个或多个元素的序列对象的子元素。TypeError如果子元素不是 则引发Element。3.2 版中的新功能。
findall(match, namespaces=None)	查找匹配match的第一个子元素。 match可以是标签名称或路径。返回一个元素实例或None。 namespaces是从命名空间前缀到全名的可选映射。作为前缀传递’'以将表达式中的所有无前缀标记名称移动到给定的命名空间中。
findtext(match, default=None, namespaces=None)	按标签名称或 路径查找所有匹配的子元素。返回包含文档顺序中所有匹配元素的列表。 namespaces是从命名空间前缀到全名的可选映射。作为前缀传递’'以将表达式中的所有无前缀标记名称移动到给定的命名空间中。
findtext(match, default=None, namespaces=None)	查找匹配match的第一个子元素的文本。 match可以是标签名称或路径。返回第一个匹配元素的文本内容，如果没有找到元素，则返回默认值。请注意，如果匹配元素没有文本内容，则返回空字符串。namespaces是从命名空间前缀到全名的可选映射。作为前缀传递’'以将表达式中的所有无前缀标记名称移动到给定的命名空间中。
insert(index, subelement)	在此元素的给定位置插入子元素。TypeError如果subelement不是 则引发 Element。
iter(tag=None)	创建一个以当前元素为根的树迭代器。迭代器按文档（深度优先）顺序迭代此元素及其下方的所有元素。如果tag不是Noneor ，则迭代器只返回’*'tag 等于tag的元素。如果在迭代过程中修改了树结构，则结果未定义。
iterfind(match, namespaces=None)	按标签名称或 路径查找所有匹配的子元素。返回一个iterable，产生文档顺序中的所有匹配元素。namespaces是从命名空间前缀到全名的可选映射。
itertext()	创建一个文本迭代器。迭代器按文档顺序循环遍历该元素和所有子元素，并返回所有内部文本。
makeelement(tag, attrib)	创建与此元素相同类型的新元素对象。不要调用此方法，使用SubElement()工厂函数。
remove(subelement)	从元素中移除子元素。与 find* 方法不同，此方法基于实例标识而不是标记值或内容来比较元素。

2.class xml.etree.ElementTree.ElementTree(element=None, file=None)
ElementTree 包装类。此类表示整个元素层次结构，并为标准 XML 的序列化添加了一些额外的支持。element是根元素。如果给定，则使用 XML文件的内容初始化树。

名称	解释
_setroot(element)	替换此树的根元素。这将丢弃树的当前内容，并将其替换为给定元素。小心使用。 element是一个元素实例。
find(match, namespaces=None)	与 相同Element.find()，从树的根开始。
findall(match, namespaces=None)	与 相同Element.findall()，从树的根开始。
findtext(match, default=None, namespaces=None)	与 相同Element.findtext()，从树的根开始。
getroot()	返回此树的根元素。
iter(tag=None)	创建并返回根元素的树迭代器。迭代器按节顺序循环遍历此树中的所有元素。 tag是要查找的标签（默认是返回所有元素）。
iterfind(match, namespaces=None)	与 相同Element.iterfind()，从树的根开始。
parse(source, parser=None)	将外部 XML 部分加载到此元素树中。 source是文件名或文件对象。 parser是一个可选的解析器实例。如果未给出，XMLParser则使用标准解析器。返回节根元素。
write(file, encoding=“us-ascii”, xml_declaration=None, default_namespace=None, method=“xml”, *, short_empty_elements=True)	将元素树以 XML 格式写入文件。 file是文件名，或为写入而打开的 文件对象。 encoding 1是输出编码（默认为 US-ASCII）。 xml_declaration控制是否应将 XML 声明添加到文件中。 仅当不是 US-ASCII 或 UTF-8 或 Unicode（默认为）时才用于False从不、True始终用于。 default_namespace设置默认的 XML 命名空间（用于“xmlns”）。 方法是,或（默认为 ）。仅关键字short_empty_elements参数控制不包含内容的元素的格式。如果NoneNone"xml"“html”“text”"xml"True（默认），它们作为单个自闭合标签发出，否则它们作为一对开始/结束标签发出。输出是字符串 ( str) 或二进制 ( bytes)。这由encoding参数控制。如果encoding为 “unicode”，则输出为字符串；否则，它是二进制的。请注意，如果它是一个打开的 文件对象，这可能与文件类型冲突；确保不要尝试将字符串写入二进制流，反之亦然。

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

在 3.3 版更改：此模块将在可用时使用快速实现。该xml.etree.cElementTree模块已弃用。警告:该xml.etree.ElementTree模块对恶意构建的数据不安全。如果您需要解析不受信任或未经身份验证的数据，请参阅XML 漏洞。