cpython_sandbox / Doc / library / xml.etree.elementtree.rst

Full commit

:mod:`xml.etree.ElementTree` --- The ElementTree XML API

The :mod:`xml.etree.ElementTree` module implements a simple and efficient API for parsing and creating XML data.


The :mod:`xml.etree.ElementTree` module is not secure against maliciously constructed data. If you need to parse untrusted or unauthenticated data see :ref:`xml-vulnerabilities`.


This is a short tutorial for using :mod:`xml.etree.ElementTree` (ET in short). The goal is to demonstrate some of the building blocks and basic concepts of the module.

XML tree and 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 - :class:`ElementTree` represents the whole XML document as a tree, and :class:`Element` represents a single node in this tree. Interactions with the whole document (reading and writing to/from files) are usually done on the :class:`ElementTree` level. Interactions with a single XML element and its sub-elements are done on the :class:`Element` level.

Parsing XML

We'll be using the following XML document as the sample data for this section:

<?xml version="1.0"?>
    <country name="Liechtenstein">
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    <country name="Singapore">
        <neighbor name="Malaysia" direction="N"/>
    <country name="Panama">
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>

We can import this data by reading from a file:

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

Or directly from a string:

root = ET.fromstring(country_data_as_string)

:func:`fromstring` parses XML from a string directly into an :class:`Element`, which is the root element of the parsed tree. Other parsing functions may create an :class:`ElementTree`. Check the documentation to be sure.

As an :class:`Element`, root has a tag and a dictionary of attributes:

>>> root.tag
>>> root.attrib

It also has children nodes over which we can iterate:

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

Children are nested, and we can access specific child nodes by index:

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

Incremental parsing

It's possible to parse XML incrementally (i.e. not the whole document at once). The most powerful tool for doing this is :class:`IncrementalParser`. It does not require a blocking read to obtain the XML data, and is instead fed with data incrementally with :meth:`IncrementalParser.data_received` calls. To get the parsed XML elements, call :meth:``. Here's an example:

>>> incparser = ET.IncrementalParser(['start', 'end'])
>>> incparser.data_received('<mytag>sometext')
>>> list(
[('start', <Element 'mytag' at 0x7fba3f2a8688>)]
>>> incparser.data_received(' more text</mytag>')
>>> for event, elem in
...   print(event)
...   print(elem.tag, 'text=', elem.text)
mytag text= sometext more text

The obvious use case is applications that operate in an asynchronous fashion where the XML data is being received from a socket or read incrementally from some storage device. In such cases, blocking reads are unacceptable.

Because it's so flexible, :class:`IncrementalParser` can be inconvenient to use for simpler use-cases. If you don't mind your application blocking on reading XML data but would still like to have incremental parsing capabilities, take a look at :func:`iterparse`. It can be useful when you're reading a large XML document and don't want to hold it wholly in memory.

Finding interesting elements

:class:`Element` has some useful methods that help iterate recursively over all the sub-tree below it (its children, their children, and so on). For example, :meth:`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'}

:meth:`Element.findall` finds only elements with a tag which are direct children of the current element. :meth:`Element.find` finds the first child with a particular tag, and :meth:`Element.text` accesses the element's text content. :meth:`Element.get` accesses the element's attributes:

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

More sophisticated specification of which elements to look for is possible by using :ref:`XPath <elementtree-xpath>`.

Modifying an XML File

:class:`ElementTree` provides a simple way to build XML documents and write them to files. The :meth:`ElementTree.write` method serves this purpose.

Once created, an :class:`Element` object may be manipulated by directly changing its fields (such as :attr:`Element.text`), adding and modifying attributes (:meth:`Element.set` method), as well as adding new children (for example with :meth:`Element.append`).

Let's say we want to add one to each country's rank, and add an updated attribute to the rank element:

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

Our XML now looks like this:

<?xml version="1.0"?>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <neighbor name="Malaysia" direction="N"/>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>

We can remove elements using :meth:`Element.remove`. Let's say we want to remove all countries with a rank higher than 50:

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

Our XML now looks like this:

<?xml version="1.0"?>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <neighbor name="Malaysia" direction="N"/>

Building XML documents

The :func:`SubElement` function also provides a convenient way to create new sub-elements for a given 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>

Additional resources

See for tutorials and links to other docs.

XPath support

This module provides limited support for XPath expressions for locating elements in a tree. The goal is to support a small subset of the abbreviated syntax; a full XPath engine is outside the scope of the module.


Here's an example that demonstrates some of the XPath capabilities of the module. We'll be using the countrydata XML document from the :ref:`Parsing XML <elementtree-parsing-xml>` section:

import xml.etree.ElementTree as ET

root = ET.fromstring(countrydata)

# Top-level elements

# All 'neighbor' grand-children of 'country' children of the top-level
# elements

# Nodes with name='Singapore' that have a 'year' child

# 'year' nodes that are children of nodes with name='Singapore'

# All 'neighbor' nodes that are the second child of their parent

Supported XPath syntax

Syntax Meaning
tag Selects all child elements with the given tag. For example, spam selects all child elements named spam, spam/egg selects all grandchildren named egg in all children named spam.
* Selects all child elements. For example, */egg selects all grandchildren named egg.
. Selects the current node. This is mostly useful at the beginning of the path, to indicate that it's a relative path.
// Selects all subelements, on all levels beneath the current element. For example, .//egg selects all egg elements in the entire tree.
.. Selects the parent element. Returns None if the path attempts to reach the ancestors of the start element (the element find was called on).
[@attrib] Selects all elements that have the given attribute.
[@attrib='value'] Selects all elements for which the given attribute has the given value. The value cannot contain quotes.
[tag] Selects all elements that have a child named tag. Only immediate children are supported.
[position] Selects all elements that are located at the given position. 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.



Element Objects

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.

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

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

:class:`Element` objects also support the following sequence type methods for working with subelements: :meth:`__delitem__`, :meth:`__getitem__`, :meth:`__setitem__`, :meth:`__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")

ElementTree Objects

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.

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

        <title>Example page</title>
        <p>Moved to <a href=""></a>
        or <a href=""></a>.</p>

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

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. :class:`QName` instances are opaque.

IncrementalParser Objects

An incremental, event-driven parser suitable for non-blocking applications. events is a sequence of events to report back. The supported events are the strings "start", "end", "start-ns" and "end-ns" (the "ns" events are used to get detailed namespace information). If events is omitted, only "end" events are reported. parser is an optional parser instance. If not given, the standard :class:`XMLParser` parser is used.


:class:`IncrementalParser` 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.

TreeBuilder Objects

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

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

XMLParser Objects

:class:`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 :class:`TreeBuilder` class. encoding [1] is optional. If given, the value overrides the encoding specified in the XML file.

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


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:


[1]The encoding string included in XML output should conform to the appropriate standards. For example, "UTF-8" is valid, but "UTF8" is not. See and