原文地址为： ZH奶酪：Python使用ElementTree解析XML【译】

19.7. `xml.etree.ElementTree` — The ElementTree XML API

源代码: Lib/xml/etree/ElementTree.py

Element类型是一种灵活的容器对象，用于在内存中存储层次数据结构。可以说是list和dictionary的交叉。

注意：

xml.etree.ElementTree 模块对含有恶意代码的数据是不安全的。如果你想处理不信任的数据请使用 XML vulnerabilities.

每个element都有一系列相关属性：

标签，用于标识该元素表示哪种数据（即元素类型）
一些属性，存储在Python dictionary中
一个文本字符串
一个可选的尾字符串
一些孩子elements，存储在Python sequence中

为了创建一个element实例，使用Element 构造函数或者SubElement()工厂函数。

ElementTree 类可以用来包裹一个element结构，用于与XML进行相互转换。

一个 C语言实现的可用 API ： xml.etree.cElementTree.

Changed in version 2.7: The ElementTree API is updated to 1.3. For more information, see Introducing ElementTree 1.3.

19.7.1. 综述

这是关于使用xml.etree.ElementTree (ET)的简要综述，目的是演示如何创建block和模块的基本概念。

19.7.1.1. XML 树和elements

XML is an inherently hierarchical data format, and the most natural way to represent it is with a tree. ET has two classes for this purpose - ElementTree 表示整个XML文档, and Element 表示树中的一个节点。遍历整个文档r（读写文件）通常使用 ElementTree 遍历单独的节点或者子节点通常使用element 。

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, 根节点 有一个tag以及一些列属性（保存在dictionary中）

 
          >>> 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 拥有一些方法来帮助我们迭代遍历其子树。例如：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的孩子的属于某个tag的element。 Element.find() 查找属于某个tag的第一个element, Element.text 访问element的文本内容。 Element.get()获取element的属性。:

 
          >>> 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.可以更加巧妙的访问element。

19.7.1.4. 修改XML文件

ElementTree 提供了一个简单的方法来建立XML文档并将其写入文件。 ElementTree.write() 提供了这个功能。

一旦被建立，一个 Element 对象可能会进行以下操作：改变文本（比如Element.text), 添加或修改属性 (Element.set() ), 添加孩子（例如 Element.append()).

假设我们想将每个国家的排名+1，并且增加一个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() 函数也提供了一个为已有element创建子element的简便方法：

 
          >>> 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. 其他资源：

See http://effbot.org/zone/element-index.htm for tutorials and links to other docs.

19.7.2. XPath

该模块提供了对XPath expressions 的有限的支持。目的是支持其中的一部分句法；完整的XPath工程超出了这个模块的范畴。

19.7.2.1. Example

 
          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`	选中符合给定tag的全部孩子elements。 For example, `spam` selects all child elements named `spam`, and `spam/egg` selects all grandchildren named `egg` in all children named `spam`.
`*`	选中全部孩子elements。 For example, `*/egg` selects all grandchildren named `egg`.
`.`	选中当前element。 This is mostly useful at the beginning of the path, to indicate that it’s a relative path.
`//`	选中同一级别的全部子element. For example, `.//egg` selects all `egg` elements in the entire tree.
`..`	选中父亲节点；
`[@attrib]`	选中含有给定属性的全部节点。
`[@attrib='value']`	选中含有给定属性以及给定属性值的全部节点。The value cannot contain quotes.
`[tag]`	选中所有拥有一个叫做tag的孩子的elements。 Only immediate children are supported.
`[position]`	选中所有位于指定位置的elements。 The position can be either an integer (1 is the first position), the expression `last()` (for the last position), or a position relative to the last position (e.g. `last()-1`).

Predicates (expressions within square brackets) must be preceded by a tag name, an asterisk, or another predicate. position predicates must be preceded by a tag name.

19.7.3. 其他相关

19.7.3.1. 函数

xml.etree.ElementTree. Comment ( text=None ): Comment element factory. This factory function creates a special element that will be serialized as an XML comment by the standard serializer. The comment string can be either a bytestring or a Unicode string. text is a string containing the comment string. Returns an element instance representing a comment.

xml.etree.ElementTree. dump ( elem )

Writes an element tree or element structure to sys.stdout. This function should be used for debugging only.

The exact output format is implementation dependent. In this version, it’s written as an ordinary XML file.

elem is an element tree or an individual element.

xml.etree.ElementTree. fromstring ( text ): Parses an XML section from a string constant. Same as XML(). text is a string containing XML data. Returns an Element instance.

xml.etree.ElementTree. fromstringlist ( sequence, parser=None ): Parses an XML document from a sequence of string fragments. sequence is a list or other sequence containing XML data fragments. parser is an optional parser instance. If not given, the standard XMLParser parser is used. Returns an Element instance.

New in version 2.7.

xml.etree.ElementTree. iselement ( element ): Checks if an object appears to be a valid element object. element is an element instance. Returns a true value if this is an element object.

xml.etree.ElementTree. iterparse ( source, events=None, parser=None ): Parses an XML section into an element tree incrementally, and reports what’s going on to the user. source is a filename or file object containing XML data. events is a list of events to report back. If omitted, only “end” events are reported. parser is an optional parser instance. If not given, the standard XMLParser parser is used. parser is not supported by cElementTree. Returns an iterator providing (event, elem) pairs.

Note

iterparse() 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.

If you need a fully populated element, look for “end” events instead.

xml.etree.ElementTree. parse ( source, parser=None ): Parses an XML section into an element tree. source is a filename or file object containing XML data. parser is an optional parser instance. If not given, the standard XMLParser parser is used. Returns an ElementTree instance.

xml.etree.ElementTree. ProcessingInstruction ( target, text=None ): PI element factory. This factory function creates a special element that will be serialized as an XML processing instruction. target is a string containing the PI target. text is a string containing the PI contents, if given. Returns an element instance, representing a processing instruction.

xml.etree.ElementTree. register_namespace ( prefix, uri ): Registers a namespace prefix. The registry is global, and any existing mapping for either the given prefix or the namespace URI will be removed. prefix is a namespace prefix. uri is a namespace uri. Tags and attributes in this namespace will be serialized with the given prefix, if at all possible.

New in version 2.7.

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

Subelement factory. This function creates an element instance, and appends it to an existing element.

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

xml.etree.ElementTree. tostring ( element, encoding="us-ascii", method="xml" ): 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). method is either "xml", "html" or "text" (default is "xml"). Returns an encoded string containing the XML data.

xml.etree.ElementTree. tostringlist ( element, encoding="us-ascii", method="xml" ): 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). method is either "xml", "html" or "text" (default is "xml"). Returns a list of encoded strings containing the XML data. It does not guarantee any specific sequence, except that "".join(tostringlist(element)) == tostring(element).

New in version 2.7.

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.

19.7.3.2. Element 对象

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: A string identifying what kind of data this element represents (the element type, in other words).

text: The text attribute can be used to hold additional data associated with the element. As the name implies this attribute is usually a string but may be any application-specific object. If the element is created from an XML file the attribute will contain any text found between the element tags.

tail: The tail attribute can be used to hold additional data associated with the element. This attribute is usually a string but may be any application-specific object. If the element is created from an XML file the attribute will contain any text found after the element’s end tag and before the next tag.

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 elements internal list of subelements.

extend ( subelements ): Appends subelements from a sequence object with zero or more elements. Raises AssertionError if a subelement is not a valid object.

New in version 2.7.

find ( match ): Finds the first subelement matching match. match may be a tag name or path. Returns an element instance or None.

findall ( match ): Finds all matching subelements, by tag name or path. Returns a list containing all matching elements in document order.

findtext ( match, default=None ): Finds text for the first subelement matching match. match may be a tag name or 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.

getchildren ( ): Deprecated since version 2.7: Use list(elem) or iteration.

getiterator ( tag=None ): Deprecated since version 2.7: Use method Element.iter() instead.

insert ( index, element ): Inserts a subelement at the given position in this 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.

New in version 2.7.

iterfind ( match ): Finds all matching subelements, by tag name or path. Returns an iterable yielding all matching elements in document order.

New in version 2.7.

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

New in version 2.7.

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"

19.7.3.3. ElementTree Objects

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 ): Same as Element.find(), starting at the root of the tree.

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

findtext ( match, default=None ): Same as Element.findtext(), starting at the root of the tree.

getiterator ( tag=None ): Deprecated since version 2.7: 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 ): Finds all matching subelements, by tag name or path. Same as getroot().iterfind(match). Returns an iterable yielding all matching elements in document order.

New in version 2.7.

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" ): 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 (default is None). default_namespace sets the default XML namespace (for “xmlns”). method is either "xml", "html" or "text" (default is "xml"). Returns an encoded string.

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

19.7.3.4. 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 an URI, and this argument is interpreted as a local name. QName instances are opaque.

19.7.3.5. TreeBuilder Objects

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

Generic element structure builder. This builder converts a sequence of start, data, and end 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. The element_factory is called to create new Element instances when given.

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.

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

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.

New in version 2.7.

19.7.3.6. XMLParser Objects

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

Element structure builder for XML source data, based on the expat parser. html are predefined HTML entities. This flag is not supported by the current implementation. target is the target object. If omitted, the builder uses an instance of the standard TreeBuilder class. encoding [1] is optional. If given, the value overrides the encoding specified in the XML file.

close ( ): Finishes feeding data to the parser. Returns an element structure.

doctype ( name, pubid, system ): Deprecated since version 2.7: Define the TreeBuilder.doctype() method on a custom TreeBuilder target.

feed ( data ): Feeds data to the parser. data is encoded data.

XMLParser.feed() calls target‘s start() method for each opening tag, its end() method for each closing tag, and data is processed by method data(). 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
 
         

转载请注明本文地址： ZH奶酪：Python使用ElementTree解析XML【译】