1 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
2 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
4 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
5 <meta name="generator" content="Docutils 0.16: http://docutils.sourceforge.net/" />
6 <title>APIs specific to lxml.etree</title>
7 <link rel="stylesheet" href="style.css" type="text/css" />
8 <script type="text/javascript">
9 function trigger_menu(event) {
10 var sidemenu = document.getElementById("sidemenu");
11 var classes = sidemenu.getAttribute("class");
12 classes = (classes.indexOf(" visible") === -1) ? classes + " visible" : classes.replace(" visible", "");
13 sidemenu.setAttribute("class", classes);
14 event.preventDefault();
15 event.stopPropagation();
17 function hide_menu() {
18 var sidemenu = document.getElementById("sidemenu");
19 var classes = sidemenu.getAttribute("class");
20 if (classes.indexOf(" visible") !== -1) {
21 sidemenu.setAttribute("class", classes.replace(" visible", ""));
24 </script><meta name="viewport" content="width=device-width, initial-scale=1" /></head>
25 <body onclick="hide_menu()">
26 <div class="document" id="apis-specific-to-lxml-etree">
27 <div class="sidemenu" id="sidemenu"><div class="menutrigger" onclick="trigger_menu(event)">Menu</div><div class="menu"><div class="banner"><div class="banner_image"><img src="python-xml-title.png" /></div><div class="banner_link"><a href="index.html#support-the-project">Like the tool? <br class="first" />Help making it better! <br class="second" />Your donation helps!</a></div></div><ul id="lxml-section"><li><span class="section title">lxml</span><ul class="menu foreign" id="index-menu"><li class="menu title"><a href="index.html">lxml</a><ul class="submenu"><li class="menu item"><a href="index.html#introduction">Introduction</a></li><li class="menu item"><a href="index.html#support-the-project">Support the project</a></li><li class="menu item"><a href="index.html#documentation">Documentation</a></li><li class="menu item"><a href="index.html#download">Download</a></li><li class="menu item"><a href="index.html#mailing-list">Mailing list</a></li><li class="menu item"><a href="index.html#bug-tracker">Bug tracker</a></li><li class="menu item"><a href="index.html#license">License</a></li><li class="menu item"><a href="index.html#old-versions">Old Versions</a></li><li class="menu item"><a href="index.html#project-income-report">Project income report</a></li><li class="menu item"><a href="index.html#legal-notice-for-donations">Legal Notice for Donations</a></li></ul></li></ul><ul class="menu foreign" id="intro-menu"><li class="menu title"><a href="intro.html">Why lxml?</a><ul class="submenu"><li class="menu item"><a href="intro.html#motto">Motto</a></li><li class="menu item"><a href="intro.html#aims">Aims</a></li></ul></li></ul><ul class="menu foreign" id="installation-menu"><li class="menu title"><a href="installation.html">Installing lxml</a><ul class="submenu"><li class="menu item"><a href="installation.html#where-to-get-it">Where to get it</a></li><li class="menu item"><a href="installation.html#requirements">Requirements</a></li><li class="menu item"><a href="installation.html#installation">Installation</a></li><li class="menu item"><a href="installation.html#building-lxml-from-dev-sources">Building lxml from dev sources</a></li><li class="menu item"><a href="installation.html#using-lxml-with-python-libxml2">Using lxml with python-libxml2</a></li><li class="menu item"><a href="installation.html#source-builds-on-ms-windows">Source builds on MS Windows</a></li><li class="menu item"><a href="installation.html#source-builds-on-macos-x">Source builds on MacOS-X</a></li></ul></li></ul><ul class="menu foreign" id="performance-menu"><li class="menu title"><a href="performance.html">Benchmarks and Speed</a><ul class="submenu"><li class="menu item"><a href="performance.html#general-notes">General notes</a></li><li class="menu item"><a href="performance.html#how-to-read-the-timings">How to read the timings</a></li><li class="menu item"><a href="performance.html#parsing-and-serialising">Parsing and Serialising</a></li><li class="menu item"><a href="performance.html#the-elementtree-api">The ElementTree API</a></li><li class="menu item"><a href="performance.html#xpath">XPath</a></li><li class="menu item"><a href="performance.html#a-longer-example">A longer example</a></li><li class="menu item"><a href="performance.html#lxml-objectify">lxml.objectify</a></li></ul></li></ul><ul class="menu foreign" id="compatibility-menu"><li class="menu title"><a href="compatibility.html">ElementTree compatibility of lxml.etree</a></li></ul><ul class="menu foreign" id="FAQ-menu"><li class="menu title"><a href="FAQ.html">lxml FAQ - Frequently Asked Questions</a><ul class="submenu"><li class="menu item"><a href="FAQ.html#general-questions">General Questions</a></li><li class="menu item"><a href="FAQ.html#installation">Installation</a></li><li class="menu item"><a href="FAQ.html#contributing">Contributing</a></li><li class="menu item"><a href="FAQ.html#bugs">Bugs</a></li><li class="menu item"><a href="FAQ.html#id1">Threading</a></li><li class="menu item"><a href="FAQ.html#parsing-and-serialisation">Parsing and Serialisation</a></li><li class="menu item"><a href="FAQ.html#xpath-and-document-traversal">XPath and Document Traversal</a></li></ul></li></ul></li></ul><ul id="Developing with lxml-section"><li><span class="section title">Developing with lxml</span><ul class="menu foreign" id="tutorial-menu"><li class="menu title"><a href="tutorial.html">The lxml.etree Tutorial</a><ul class="submenu"><li class="menu item"><a href="tutorial.html#the-element-class">The Element class</a></li><li class="menu item"><a href="tutorial.html#the-elementtree-class">The ElementTree class</a></li><li class="menu item"><a href="tutorial.html#parsing-from-strings-and-files">Parsing from strings and files</a></li><li class="menu item"><a href="tutorial.html#namespaces">Namespaces</a></li><li class="menu item"><a href="tutorial.html#the-e-factory">The E-factory</a></li><li class="menu item"><a href="tutorial.html#elementpath">ElementPath</a></li></ul></li></ul><ul class="menu foreign" id="apidoc lxml-menu"><li class="menu title"><a href="apidoc/lxml.html">API reference</a></li></ul><ul class="menu current" id="api-menu"><li class="menu title"><a href="api.html">APIs specific to lxml.etree</a><ul class="submenu"><li class="menu item"><a href="api.html#lxml-etree">lxml.etree</a></li><li class="menu item"><a href="api.html#other-element-apis">Other Element APIs</a></li><li class="menu item"><a href="api.html#trees-and-documents">Trees and Documents</a></li><li class="menu item"><a href="api.html#iteration">Iteration</a></li><li class="menu item"><a href="api.html#error-handling-on-exceptions">Error handling on exceptions</a></li><li class="menu item"><a href="api.html#error-logging">Error logging</a></li><li class="menu item"><a href="api.html#serialisation">Serialisation</a></li><li class="menu item"><a href="api.html#incremental-xml-generation">Incremental XML generation</a></li><li class="menu item"><a href="api.html#cdata">CDATA</a></li><li class="menu item"><a href="api.html#xinclude-and-elementinclude">XInclude and ElementInclude</a></li></ul></li></ul><ul class="menu foreign" id="parsing-menu"><li class="menu title"><a href="parsing.html">Parsing XML and HTML with lxml</a><ul class="submenu"><li class="menu item"><a href="parsing.html#parsers">Parsers</a></li><li class="menu item"><a href="parsing.html#the-target-parser-interface">The target parser interface</a></li><li class="menu item"><a href="parsing.html#the-feed-parser-interface">The feed parser interface</a></li><li class="menu item"><a href="parsing.html#incremental-event-parsing">Incremental event parsing</a></li><li class="menu item"><a href="parsing.html#iterparse-and-iterwalk">iterparse and iterwalk</a></li><li class="menu item"><a href="parsing.html#python-unicode-strings">Python unicode strings</a></li></ul></li></ul><ul class="menu foreign" id="validation-menu"><li class="menu title"><a href="validation.html">Validation with lxml</a><ul class="submenu"><li class="menu item"><a href="validation.html#validation-at-parse-time">Validation at parse time</a></li><li class="menu item"><a href="validation.html#id1">DTD</a></li><li class="menu item"><a href="validation.html#relaxng">RelaxNG</a></li><li class="menu item"><a href="validation.html#xmlschema">XMLSchema</a></li><li class="menu item"><a href="validation.html#id2">Schematron</a></li><li class="menu item"><a href="validation.html#id3">(Pre-ISO-Schematron)</a></li></ul></li></ul><ul class="menu foreign" id="xpathxslt-menu"><li class="menu title"><a href="xpathxslt.html">XPath and XSLT with lxml</a><ul class="submenu"><li class="menu item"><a href="xpathxslt.html#xpath">XPath</a></li><li class="menu item"><a href="xpathxslt.html#xslt">XSLT</a></li></ul></li></ul><ul class="menu foreign" id="objectify-menu"><li class="menu title"><a href="objectify.html">lxml.objectify</a><ul class="submenu"><li class="menu item"><a href="objectify.html#the-lxml-objectify-api">The lxml.objectify API</a></li><li class="menu item"><a href="objectify.html#asserting-a-schema">Asserting a Schema</a></li><li class="menu item"><a href="objectify.html#objectpath">ObjectPath</a></li><li class="menu item"><a href="objectify.html#python-data-types">Python data types</a></li><li class="menu item"><a href="objectify.html#how-data-types-are-matched">How data types are matched</a></li><li class="menu item"><a href="objectify.html#what-is-different-from-lxml-etree">What is different from lxml.etree?</a></li></ul></li></ul><ul class="menu foreign" id="lxmlhtml-menu"><li class="menu title"><a href="lxmlhtml.html">lxml.html</a><ul class="submenu"><li class="menu item"><a href="lxmlhtml.html#parsing-html">Parsing HTML</a></li><li class="menu item"><a href="lxmlhtml.html#html-element-methods">HTML Element Methods</a></li><li class="menu item"><a href="lxmlhtml.html#running-html-doctests">Running HTML doctests</a></li><li class="menu item"><a href="lxmlhtml.html#creating-html-with-the-e-factory">Creating HTML with the E-factory</a></li><li class="menu item"><a href="lxmlhtml.html#working-with-links">Working with links</a></li><li class="menu item"><a href="lxmlhtml.html#forms">Forms</a></li><li class="menu item"><a href="lxmlhtml.html#cleaning-up-html">Cleaning up HTML</a></li><li class="menu item"><a href="lxmlhtml.html#html-diff">HTML Diff</a></li><li class="menu item"><a href="lxmlhtml.html#examples">Examples</a></li></ul></li></ul><ul class="menu foreign" id="cssselect-menu"><li class="menu title"><a href="cssselect.html">lxml.cssselect</a><ul class="submenu"><li class="menu item"><a href="cssselect.html#the-cssselector-class">The CSSSelector class</a></li><li class="menu item"><a href="cssselect.html#the-cssselect-method">The cssselect method</a></li><li class="menu item"><a href="cssselect.html#supported-selectors">Supported Selectors</a></li><li class="menu item"><a href="cssselect.html#namespaces">Namespaces</a></li></ul></li></ul><ul class="menu foreign" id="elementsoup-menu"><li class="menu title"><a href="elementsoup.html">BeautifulSoup Parser</a><ul class="submenu"><li class="menu item"><a href="elementsoup.html#parsing-with-the-soupparser">Parsing with the soupparser</a></li><li class="menu item"><a href="elementsoup.html#entity-handling">Entity handling</a></li><li class="menu item"><a href="elementsoup.html#using-soupparser-as-a-fallback">Using soupparser as a fallback</a></li><li class="menu item"><a href="elementsoup.html#using-only-the-encoding-detection">Using only the encoding detection</a></li></ul></li></ul><ul class="menu foreign" id="html5parser-menu"><li class="menu title"><a href="html5parser.html">html5lib Parser</a><ul class="submenu"><li class="menu item"><a href="html5parser.html#differences-to-regular-html-parsing">Differences to regular HTML parsing</a></li><li class="menu item"><a href="html5parser.html#function-reference">Function Reference</a></li></ul></li></ul></li></ul><ul id="Extending lxml-section"><li><span class="section title">Extending lxml</span><ul class="menu foreign" id="resolvers-menu"><li class="menu title"><a href="resolvers.html">Document loading and URL resolving</a><ul class="submenu"><li class="menu item"><a href="resolvers.html#xml-catalogs">XML Catalogs</a></li><li class="menu item"><a href="resolvers.html#uri-resolvers">URI Resolvers</a></li><li class="menu item"><a href="resolvers.html#document-loading-in-context">Document loading in context</a></li><li class="menu item"><a href="resolvers.html#i-o-access-control-in-xslt">I/O access control in XSLT</a></li></ul></li></ul><ul class="menu foreign" id="extensions-menu"><li class="menu title"><a href="extensions.html">Python extensions for XPath and XSLT</a><ul class="submenu"><li class="menu item"><a href="extensions.html#xpath-extension-functions">XPath Extension functions</a></li><li class="menu item"><a href="extensions.html#xslt-extension-elements">XSLT extension elements</a></li></ul></li></ul><ul class="menu foreign" id="element classes-menu"><li class="menu title"><a href="element_classes.html">Using custom Element classes in lxml</a><ul class="submenu"><li class="menu item"><a href="element_classes.html#background-on-element-proxies">Background on Element proxies</a></li><li class="menu item"><a href="element_classes.html#element-initialization">Element initialization</a></li><li class="menu item"><a href="element_classes.html#setting-up-a-class-lookup-scheme">Setting up a class lookup scheme</a></li><li class="menu item"><a href="element_classes.html#generating-xml-with-custom-classes">Generating XML with custom classes</a></li><li class="menu item"><a href="element_classes.html#id1">Implementing namespaces</a></li></ul></li></ul><ul class="menu foreign" id="sax-menu"><li class="menu title"><a href="sax.html">Sax support</a><ul class="submenu"><li class="menu item"><a href="sax.html#building-a-tree-from-sax-events">Building a tree from SAX events</a></li><li class="menu item"><a href="sax.html#producing-sax-events-from-an-elementtree-or-element">Producing SAX events from an ElementTree or Element</a></li><li class="menu item"><a href="sax.html#interfacing-with-pulldom-minidom">Interfacing with pulldom/minidom</a></li></ul></li></ul><ul class="menu foreign" id="capi-menu"><li class="menu title"><a href="capi.html">The public C-API of lxml.etree</a><ul class="submenu"><li class="menu item"><a href="capi.html#passing-generated-trees-through-python">Passing generated trees through Python</a></li><li class="menu item"><a href="capi.html#writing-external-modules-in-cython">Writing external modules in Cython</a></li><li class="menu item"><a href="capi.html#writing-external-modules-in-c">Writing external modules in C</a></li></ul></li></ul></li></ul><ul id="Developing lxml-section"><li><span class="section title">Developing lxml</span><ul class="menu foreign" id="build-menu"><li class="menu title"><a href="build.html">How to build lxml from source</a><ul class="submenu"><li class="menu item"><a href="build.html#cython">Cython</a></li><li class="menu item"><a href="build.html#github-git-and-hg">Github, git and hg</a></li><li class="menu item"><a href="build.html#building-the-sources">Building the sources</a></li><li class="menu item"><a href="build.html#running-the-tests-and-reporting-errors">Running the tests and reporting errors</a></li><li class="menu item"><a href="build.html#building-an-egg-or-wheel">Building an egg or wheel</a></li><li class="menu item"><a href="build.html#building-lxml-on-macos-x">Building lxml on MacOS-X</a></li><li class="menu item"><a href="build.html#static-linking-on-windows">Static linking on Windows</a></li><li class="menu item"><a href="build.html#building-debian-packages-from-svn-sources">Building Debian packages from SVN sources</a></li></ul></li></ul><ul class="menu foreign" id="lxml source howto-menu"><li class="menu title"><a href="lxml-source-howto.html">How to read the source of lxml</a><ul class="submenu"><li class="menu item"><a href="lxml-source-howto.html#what-is-cython">What is Cython?</a></li><li class="menu item"><a href="lxml-source-howto.html#where-to-start">Where to start?</a></li><li class="menu item"><a href="lxml-source-howto.html#lxml-etree">lxml.etree</a></li><li class="menu item"><a href="lxml-source-howto.html#python-modules">Python modules</a></li><li class="menu item"><a href="lxml-source-howto.html#lxml-objectify">lxml.objectify</a></li><li class="menu item"><a href="lxml-source-howto.html#lxml-html">lxml.html</a></li></ul></li></ul><ul class="menu foreign" id="changes 4 6 0-menu"><li class="menu title"><a href="changes-4.6.0.html">Release Changelog</a></li></ul><ul class="menu foreign" id="credits-menu"><li class="menu title"><a href="credits.html">Credits</a><ul class="submenu"><li class="menu item"><a href="credits.html#main-contributors">Main contributors</a></li><li class="menu item"><a href="credits.html#special-thanks-goes-to">Special thanks goes to:</a></li></ul></li></ul></li><li><a href="/sitemap.html">Sitemap</a></li></ul></div></div><div class="banner"><div class="banner_image"><img src="python-xml-title.png" /></div><div class="banner_link"><a href="index.html#support-the-project">Like the tool? <br class="first" />Help making it better! <br class="second" />Your donation helps!</a></div></div><h1 class="title">APIs specific to lxml.etree</h1>
29 <p>lxml.etree tries to follow established APIs wherever possible. Sometimes,
30 however, the need to expose a feature in an easy way led to the invention of a
31 new API. This page describes the major differences and a few additions to the
32 main ElementTree API.</p>
33 <p>For a complete reference of the API, see the <a class="reference external" href="api/index.html">generated API
34 documentation</a>.</p>
35 <p>Separate pages describe the support for <a class="reference external" href="parsing.html">parsing XML</a>, executing <a class="reference external" href="xpathxslt.html">XPath and
36 XSLT</a>, <a class="reference external" href="validation.html">validating XML</a> and interfacing with other XML tools through the
37 <a class="reference external" href="sax.html">SAX-API</a>.</p>
38 <p>lxml is extremely extensible through <a class="reference external" href="extensions.html">XPath functions in Python</a>, custom
39 <a class="reference external" href="element_classes.html">Python element classes</a>, custom <a class="reference external" href="resolvers.html">URL resolvers</a> and even <a class="reference external" href="capi.html">at the C-level</a>.</p>
40 <div class="contents topic" id="contents">
41 <p class="topic-title">Contents</p>
43 <li><a class="reference internal" href="#lxml-etree" id="id1">lxml.etree</a></li>
44 <li><a class="reference internal" href="#other-element-apis" id="id2">Other Element APIs</a></li>
45 <li><a class="reference internal" href="#trees-and-documents" id="id3">Trees and Documents</a></li>
46 <li><a class="reference internal" href="#iteration" id="id4">Iteration</a></li>
47 <li><a class="reference internal" href="#error-handling-on-exceptions" id="id5">Error handling on exceptions</a></li>
48 <li><a class="reference internal" href="#error-logging" id="id6">Error logging</a></li>
49 <li><a class="reference internal" href="#serialisation" id="id7">Serialisation</a><ul>
50 <li><a class="reference internal" href="#c14n" id="id8">C14N</a></li>
51 <li><a class="reference internal" href="#pretty-printing" id="id9">Pretty printing</a></li>
52 <li><a class="reference internal" href="#xml-declaration" id="id10">XML declaration</a></li>
55 <li><a class="reference internal" href="#incremental-xml-generation" id="id11">Incremental XML generation</a></li>
56 <li><a class="reference internal" href="#cdata" id="id12">CDATA</a></li>
57 <li><a class="reference internal" href="#xinclude-and-elementinclude" id="id13">XInclude and ElementInclude</a></li>
60 <div class="section" id="lxml-etree">
62 <p>lxml.etree tries to follow the <a class="reference external" href="http://effbot.org/zone/element-index.htm">ElementTree API</a> wherever it can. There are
63 however some incompatibilities (see <a class="reference external" href="compatibility.html">compatibility</a>). The extensions are
65 <p>If you need to know which version of lxml is installed, you can access the
66 <tt class="docutils literal">lxml.etree.LXML_VERSION</tt> attribute to retrieve a version tuple. Note,
67 however, that it did not exist before version 1.0, so you will get an
68 AttributeError in older versions. The versions of libxml2 and libxslt are
69 available through the attributes <tt class="docutils literal">LIBXML_VERSION</tt> and <tt class="docutils literal">LIBXSLT_VERSION</tt>.</p>
70 <p>The following examples usually assume this to be executed first:</p>
71 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">lxml</span> <span class="kn">import</span> <span class="n">etree</span>
74 <div class="section" id="other-element-apis">
75 <h1>Other Element APIs</h1>
76 <p>While lxml.etree itself uses the ElementTree API, it is possible to replace
77 the Element implementation by <a class="reference external" href="element_classes.html">custom element subclasses</a>. This has been
78 used to implement well-known XML APIs on top of lxml. For example, lxml ships
79 with a data-binding implementation called <a class="reference external" href="objectify.html">objectify</a>, which is similar to
80 the <a class="reference external" href="http://uche.ogbuji.net/tech/4suite/amara/">Amara bindery</a> tool.</p>
81 <p>lxml.etree comes with a number of <a class="reference external" href="element_classes.html#setting-up-a-class-lookup-scheme">different lookup schemes</a> to customize the
82 mapping between libxml2 nodes and the Element classes used by lxml.etree.</p>
84 <div class="section" id="trees-and-documents">
85 <h1>Trees and Documents</h1>
86 <p>Compared to the original ElementTree API, lxml.etree has an extended tree
87 model. It knows about parents and siblings of elements:</p>
88 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">root</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">Element</span><span class="p">(</span><span class="s2">"root"</span><span class="p">)</span>
89 <span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="s2">"a"</span><span class="p">)</span>
90 <span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">)</span>
91 <span class="gp">>>> </span><span class="n">c</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">)</span>
92 <span class="gp">>>> </span><span class="n">d</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="s2">"d"</span><span class="p">)</span>
93 <span class="gp">>>> </span><span class="n">e</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">d</span><span class="p">,</span> <span class="s2">"e"</span><span class="p">)</span>
94 <span class="gp">>>> </span><span class="n">b</span><span class="o">.</span><span class="n">getparent</span><span class="p">()</span> <span class="o">==</span> <span class="n">root</span>
95 <span class="go">True</span>
96 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">b</span><span class="o">.</span><span class="n">getnext</span><span class="p">()</span><span class="o">.</span><span class="n">tag</span><span class="p">)</span>
97 <span class="go">c</span>
98 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">c</span><span class="o">.</span><span class="n">getprevious</span><span class="p">()</span><span class="o">.</span><span class="n">tag</span><span class="p">)</span>
99 <span class="go">b</span>
101 <p>Elements always live within a document context in lxml. This implies that
102 there is also a notion of an absolute document root. You can retrieve an
103 ElementTree for the root node of a document from any of its elements.</p>
104 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">tree</span> <span class="o">=</span> <span class="n">d</span><span class="o">.</span><span class="n">getroottree</span><span class="p">()</span>
105 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">tree</span><span class="o">.</span><span class="n">getroot</span><span class="p">()</span><span class="o">.</span><span class="n">tag</span><span class="p">)</span>
106 <span class="go">root</span>
108 <p>Note that this is different from wrapping an Element in an ElementTree. You
109 can use ElementTrees to create XML trees with an explicit root node:</p>
110 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">tree</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">ElementTree</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>
111 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">tree</span><span class="o">.</span><span class="n">getroot</span><span class="p">()</span><span class="o">.</span><span class="n">tag</span><span class="p">)</span>
112 <span class="go">d</span>
113 <span class="gp">>>> </span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">tree</span><span class="p">)</span>
114 <span class="go">b'<d><e/></d>'</span>
116 <p>ElementTree objects are serialised as complete documents, including
117 preceding or trailing processing instructions and comments.</p>
118 <p>All operations that you run on such an ElementTree (like XPath, XSLT, etc.)
119 will understand the explicitly chosen root as root node of a document. They
120 will not see any elements outside the ElementTree. However, ElementTrees do
121 not modify their Elements:</p>
122 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">element</span> <span class="o">=</span> <span class="n">tree</span><span class="o">.</span><span class="n">getroot</span><span class="p">()</span>
123 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">element</span><span class="o">.</span><span class="n">tag</span><span class="p">)</span>
124 <span class="go">d</span>
125 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">element</span><span class="o">.</span><span class="n">getparent</span><span class="p">()</span><span class="o">.</span><span class="n">tag</span><span class="p">)</span>
126 <span class="go">root</span>
127 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">element</span><span class="o">.</span><span class="n">getroottree</span><span class="p">()</span><span class="o">.</span><span class="n">getroot</span><span class="p">()</span><span class="o">.</span><span class="n">tag</span><span class="p">)</span>
128 <span class="go">root</span>
130 <p>The rule is that all operations that are applied to Elements use either the
131 Element itself as reference point, or the absolute root of the document that
132 contains this Element (e.g. for absolute XPath expressions). All operations
133 on an ElementTree use its explicit root node as reference.</p>
135 <div class="section" id="iteration">
137 <p>The ElementTree API makes Elements iterable to supports iteration over their
138 children. Using the tree defined above, we get:</p>
139 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="p">[</span> <span class="n">child</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">child</span> <span class="ow">in</span> <span class="n">root</span> <span class="p">]</span>
140 <span class="go">['a', 'b', 'c', 'd']</span>
142 <p>To iterate in the opposite direction, use the builtin <tt class="docutils literal">reversed()</tt> function.</p>
143 <p>Tree traversal should use the <tt class="docutils literal">element.iter()</tt> method:</p>
144 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="p">[</span> <span class="n">el</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">el</span> <span class="ow">in</span> <span class="n">root</span><span class="o">.</span><span class="n">iter</span><span class="p">()</span> <span class="p">]</span>
145 <span class="go">['root', 'a', 'b', 'c', 'd', 'e']</span>
147 <p>lxml.etree also supports this, but additionally features an extended API for
148 iteration over the children, following/preceding siblings, ancestors and
149 descendants of an element, as defined by the respective XPath axis:</p>
150 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="p">[</span> <span class="n">child</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">child</span> <span class="ow">in</span> <span class="n">root</span><span class="o">.</span><span class="n">iterchildren</span><span class="p">()</span> <span class="p">]</span>
151 <span class="go">['a', 'b', 'c', 'd']</span>
152 <span class="gp">>>> </span><span class="p">[</span> <span class="n">child</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">child</span> <span class="ow">in</span> <span class="n">root</span><span class="o">.</span><span class="n">iterchildren</span><span class="p">(</span><span class="nb">reversed</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="p">]</span>
153 <span class="go">['d', 'c', 'b', 'a']</span>
154 <span class="gp">>>> </span><span class="p">[</span> <span class="n">sibling</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">sibling</span> <span class="ow">in</span> <span class="n">b</span><span class="o">.</span><span class="n">itersiblings</span><span class="p">()</span> <span class="p">]</span>
155 <span class="go">['c', 'd']</span>
156 <span class="gp">>>> </span><span class="p">[</span> <span class="n">sibling</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">sibling</span> <span class="ow">in</span> <span class="n">c</span><span class="o">.</span><span class="n">itersiblings</span><span class="p">(</span><span class="n">preceding</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="p">]</span>
157 <span class="go">['b', 'a']</span>
158 <span class="gp">>>> </span><span class="p">[</span> <span class="n">ancestor</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">ancestor</span> <span class="ow">in</span> <span class="n">e</span><span class="o">.</span><span class="n">iterancestors</span><span class="p">()</span> <span class="p">]</span>
159 <span class="go">['d', 'root']</span>
160 <span class="gp">>>> </span><span class="p">[</span> <span class="n">el</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">el</span> <span class="ow">in</span> <span class="n">root</span><span class="o">.</span><span class="n">iterdescendants</span><span class="p">()</span> <span class="p">]</span>
161 <span class="go">['a', 'b', 'c', 'd', 'e']</span>
163 <p>Note how <tt class="docutils literal">element.iterdescendants()</tt> does not include the element
164 itself, as opposed to <tt class="docutils literal">element.iter()</tt>. The latter effectively
165 implements the 'descendant-or-self' axis in XPath.</p>
166 <p>All of these iterators support one (or more, since lxml 3.0) additional
167 arguments that filter the generated elements by tag name:</p>
168 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="p">[</span> <span class="n">child</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">child</span> <span class="ow">in</span> <span class="n">root</span><span class="o">.</span><span class="n">iterchildren</span><span class="p">(</span><span class="s1">'a'</span><span class="p">)</span> <span class="p">]</span>
169 <span class="go">['a']</span>
170 <span class="gp">>>> </span><span class="p">[</span> <span class="n">child</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">child</span> <span class="ow">in</span> <span class="n">d</span><span class="o">.</span><span class="n">iterchildren</span><span class="p">(</span><span class="s1">'a'</span><span class="p">)</span> <span class="p">]</span>
171 <span class="go">[]</span>
172 <span class="gp">>>> </span><span class="p">[</span> <span class="n">el</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">el</span> <span class="ow">in</span> <span class="n">root</span><span class="o">.</span><span class="n">iterdescendants</span><span class="p">(</span><span class="s1">'d'</span><span class="p">)</span> <span class="p">]</span>
173 <span class="go">['d']</span>
174 <span class="gp">>>> </span><span class="p">[</span> <span class="n">el</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">el</span> <span class="ow">in</span> <span class="n">root</span><span class="o">.</span><span class="n">iter</span><span class="p">(</span><span class="s1">'d'</span><span class="p">)</span> <span class="p">]</span>
175 <span class="go">['d']</span>
176 <span class="gp">>>> </span><span class="p">[</span> <span class="n">el</span><span class="o">.</span><span class="n">tag</span> <span class="k">for</span> <span class="n">el</span> <span class="ow">in</span> <span class="n">root</span><span class="o">.</span><span class="n">iter</span><span class="p">(</span><span class="s1">'d'</span><span class="p">,</span> <span class="s1">'a'</span><span class="p">)</span> <span class="p">]</span>
177 <span class="go">['a', 'd']</span>
179 <p>Note that the order of the elements is determined by the iteration order,
180 which is the document order in most cases (except for preceding siblings
181 and ancestors, where it is the reversed document order). The order of
182 the tag selection arguments is irrelevant, as you can see in the last
184 <p>The most common way to traverse an XML tree is depth-first, which
185 traverses the tree in document order. This is implemented by the
186 <tt class="docutils literal">.iter()</tt> method. While there is no dedicated method for
187 breadth-first traversal, it is almost as simple if you use the
188 <tt class="docutils literal">collections.deque</tt> type.</p>
189 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">root</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">XML</span><span class="p">(</span><span class="s1">'<root><a><b/><c/></a><d><e/></d></root>'</span><span class="p">)</span>
190 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="n">pretty_print</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s1">'unicode'</span><span class="p">))</span>
191 <span class="go"><root></span>
192 <span class="go"> <a></span>
193 <span class="go"> <b/></span>
194 <span class="go"> <c/></span>
195 <span class="go"> </a></span>
196 <span class="go"> <d></span>
197 <span class="go"> <e/></span>
198 <span class="go"> </d></span>
199 <span class="go"></root></span>
201 <span class="gp">>>> </span><span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">deque</span>
202 <span class="gp">>>> </span><span class="n">queue</span> <span class="o">=</span> <span class="n">deque</span><span class="p">([</span><span class="n">root</span><span class="p">])</span>
203 <span class="gp">>>> </span><span class="k">while</span> <span class="n">queue</span><span class="p">:</span>
204 <span class="gp">... </span> <span class="n">el</span> <span class="o">=</span> <span class="n">queue</span><span class="o">.</span><span class="n">popleft</span><span class="p">()</span> <span class="c1"># pop next element</span>
205 <span class="gp">... </span> <span class="n">queue</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">el</span><span class="p">)</span> <span class="c1"># append its children</span>
206 <span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="n">el</span><span class="o">.</span><span class="n">tag</span><span class="p">)</span>
207 <span class="go">root</span>
208 <span class="go">a</span>
209 <span class="go">d</span>
210 <span class="go">b</span>
211 <span class="go">c</span>
212 <span class="go">e</span>
214 <p>See also the section on the utility functions <tt class="docutils literal">iterparse()</tt> and
215 <tt class="docutils literal">iterwalk()</tt> in the <a class="reference external" href="parsing.html#iterparse-and-iterwalk">parser documentation</a>.</p>
217 <div class="section" id="error-handling-on-exceptions">
218 <h1>Error handling on exceptions</h1>
219 <p>Libxml2 provides error messages for failures, be it during parsing, XPath
220 evaluation or schema validation. The preferred way of accessing them is
221 through the local <tt class="docutils literal">error_log</tt> property of the respective evaluator or
222 transformer object. See their documentation for details.</p>
223 <p>However, lxml also keeps a global error log of all errors that occurred at the
224 application level. Whenever an exception is raised, you can retrieve the
225 errors that occurred and "might have" lead to the problem from the error log
226 copy attached to the exception:</p>
227 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">etree</span><span class="o">.</span><span class="n">clear_error_log</span><span class="p">()</span>
228 <span class="gp">>>> </span><span class="n">broken_xml</span> <span class="o">=</span> <span class="s1">'''</span>
229 <span class="gp">... </span><span class="s1"><root></span>
230 <span class="gp">... </span><span class="s1"> <a></span>
231 <span class="gp">... </span><span class="s1"></root></span>
232 <span class="gp">... </span><span class="s1">'''</span>
233 <span class="gp">>>> </span><span class="k">try</span><span class="p">:</span>
234 <span class="gp">... </span> <span class="n">etree</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="n">StringIO</span><span class="p">(</span><span class="n">broken_xml</span><span class="p">))</span>
235 <span class="gp">... </span><span class="k">except</span> <span class="n">etree</span><span class="o">.</span><span class="n">XMLSyntaxError</span><span class="p">,</span> <span class="n">e</span><span class="p">:</span>
236 <span class="gp">... </span> <span class="k">pass</span> <span class="c1"># just put the exception into e</span>
238 <p>Once you have caught this exception, you can access its <tt class="docutils literal">error_log</tt> property
239 to retrieve the log entries or filter them by a specific type, error domain or
241 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">log</span> <span class="o">=</span> <span class="n">e</span><span class="o">.</span><span class="n">error_log</span><span class="o">.</span><span class="n">filter_from_level</span><span class="p">(</span><span class="n">etree</span><span class="o">.</span><span class="n">ErrorLevels</span><span class="o">.</span><span class="n">FATAL</span><span class="p">)</span>
242 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">log</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
243 <span class="go"><string>:4:8:FATAL:PARSER:ERR_TAG_NAME_MISMATCH: Opening and ending tag mismatch: a line 3 and root</span>
245 <p>This might look a little cryptic at first, but it is the information that
246 libxml2 gives you. At least the message at the end should give you a hint
247 what went wrong and you can see that the fatal errors (FATAL) happened during
248 parsing (PARSER) lines 4, column 8 and line 5, column 1 of a string (<string>,
249 or the filename if available). Here, PARSER is the so-called error domain,
250 see <tt class="docutils literal">lxml.etree.ErrorDomains</tt> for that. You can get it from a log entry
252 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">entry</span> <span class="o">=</span> <span class="n">log</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
253 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">entry</span><span class="o">.</span><span class="n">domain_name</span><span class="p">)</span>
254 <span class="go">PARSER</span>
255 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">entry</span><span class="o">.</span><span class="n">type_name</span><span class="p">)</span>
256 <span class="go">ERR_TAG_NAME_MISMATCH</span>
257 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">entry</span><span class="o">.</span><span class="n">filename</span><span class="p">)</span>
258 <span class="go"><string></span>
260 <p>There is also a convenience attribute <tt class="docutils literal">error_log.last_error</tt> that returns the
261 last error or fatal error that occurred, so that it's easy to test if there was
262 an error at all. Note, however, that there might have been more than one error,
263 and the first error that occurred might be more relevant in some cases.</p>
265 <div class="section" id="error-logging">
266 <h1>Error logging</h1>
267 <p>lxml.etree supports logging libxml2 messages to the Python stdlib logging
268 module. This is done through the <tt class="docutils literal">etree.PyErrorLog</tt> class. It disables the
269 error reporting from exceptions and forwards log messages to a Python logger.
270 To use it, see the descriptions of the function <tt class="docutils literal">etree.useGlobalPythonLog</tt>
271 and the class <tt class="docutils literal">etree.PyErrorLog</tt> for help. Note that this does not affect
272 the local error logs of XSLT, XMLSchema, etc.</p>
274 <div class="section" id="serialisation">
275 <h1>Serialisation</h1>
276 <div class="section" id="c14n">
278 <p>lxml.etree has support for <a class="reference external" href="https://www.w3.org/TR/xml-exc-c14n/">C14N 1.0</a>
279 and <a class="reference external" href="https://www.w3.org/TR/xml-c14n2/">C14N 2.0</a>. When serialising an XML
280 tree using <tt class="docutils literal">ElementTree.write()</tt> or <tt class="docutils literal">tostring()</tt>, you can pass the option
281 <tt class="docutils literal"><span class="pre">method="c14n"</span></tt> for 1.0 or <tt class="docutils literal"><span class="pre">method="c14n2"</span></tt> for 2.0.</p>
282 <p>Additionally, there is a function <tt class="docutils literal">etree.canonicalize()</tt> which can be used
283 to convert serialised XML to its canonical form directly, without creating
284 a tree in memory. By default, it returns the canonical output, but can be
285 directed to write it to a file instead.</p>
286 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">c14n_xml</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">canonicalize</span><span class="p">(</span><span class="s2">"<root><test z='1' y='2'/></root>"</span><span class="p">)</span>
287 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">c14n_xml</span><span class="p">)</span>
288 <span class="go"><root><test y="2" z="1"></test></root></span>
291 <div class="section" id="pretty-printing">
292 <h2>Pretty printing</h2>
293 <p>Functions like <tt class="docutils literal">ElementTree.write()</tt> and <tt class="docutils literal">tostring()</tt> also support pretty
294 printing XML through a keyword argument:</p>
295 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">root</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">XML</span><span class="p">(</span><span class="s2">"<root><test/></root>"</span><span class="p">)</span>
296 <span class="gp">>>> </span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">root</span><span class="p">)</span>
297 <span class="go">b'<root><test/></root>'</span>
299 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="n">pretty_print</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span>
300 <span class="go"><root></span>
301 <span class="go"> <test/></span>
302 <span class="go"></root></span>
304 <p>Note the newline that is appended at the end when pretty printing the
305 output. It was added in lxml 2.0.</p>
307 <div class="section" id="xml-declaration">
308 <h2>XML declaration</h2>
309 <p>By default, lxml (just as ElementTree) outputs the XML declaration only if it
310 is required by the standard:</p>
311 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">unicode_root</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">Element</span><span class="p">(</span> <span class="sa">u</span><span class="s2">"t</span><span class="se">\u3120</span><span class="s2">st"</span> <span class="p">)</span>
312 <span class="gp">>>> </span><span class="n">unicode_root</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="sa">u</span><span class="s2">"t</span><span class="se">\u0A0A</span><span class="s2">st"</span>
313 <span class="gp">>>> </span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">unicode_root</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">"utf-8"</span><span class="p">)</span>
314 <span class="go">b'<t\xe3\x84\xa0st>t\xe0\xa8\x8ast</t\xe3\x84\xa0st>'</span>
316 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">unicode_root</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">"iso-8859-1"</span><span class="p">))</span>
317 <span class="go"><?xml version='1.0' encoding='iso-8859-1'?></span>
318 <span class="go"><t&#12576;st>t&#2570;st</t&#12576;st></span>
320 <p>Also see the general remarks on <a class="reference external" href="parsing.html#python-unicode-strings">Unicode support</a>.</p>
321 <p>You can enable or disable the declaration explicitly by passing another
322 keyword argument for the serialisation:</p>
323 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="n">xml_declaration</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span>
324 <span class="go"><?xml version='1.0' encoding='ASCII'?></span>
325 <span class="go"><root><test/></root></span>
327 <span class="gp">>>> </span><span class="n">unicode_root</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
328 <span class="gp">>>> </span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">unicode_root</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">"UTF-16LE"</span><span class="p">,</span>
329 <span class="gp">... </span> <span class="n">xml_declaration</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
330 <span class="go">b'<\x00t\x00 1s\x00t\x00/\x00>\x00'</span>
332 <p>Note that a standard compliant XML parser will not consider the last line
333 well-formed XML if the encoding is not explicitly provided somehow, e.g. in an
334 underlying transport protocol:</p>
335 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">notxml</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">unicode_root</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">"UTF-16LE"</span><span class="p">,</span>
336 <span class="gp">... </span> <span class="n">xml_declaration</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
337 <span class="gp">>>> </span><span class="n">root</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">XML</span><span class="p">(</span><span class="n">notxml</span><span class="p">)</span> <span class="c1">#doctest: +ELLIPSIS</span>
338 <span class="gt">Traceback (most recent call last):</span>
339 <span class="c">...</span>
340 <span class="gr">lxml.etree.XMLSyntaxError</span>: <span class="n">...</span>
342 <p>Since version 2.3, the serialisation can override the internal subset
343 of the document with a user provided DOCTYPE:</p>
344 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">xml</span> <span class="o">=</span> <span class="s1">'<!DOCTYPE root></span><span class="se">\n</span><span class="s1"><root/>'</span>
345 <span class="gp">>>> </span><span class="n">tree</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="n">StringIO</span><span class="p">(</span><span class="n">xml</span><span class="p">))</span>
347 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">tree</span><span class="p">))</span>
348 <span class="go"><!DOCTYPE root></span>
349 <span class="go"><root/></span>
351 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">tree</span><span class="p">,</span>
352 <span class="gp">... </span> <span class="n">doctype</span><span class="o">=</span><span class="s1">'<!DOCTYPE root SYSTEM "/tmp/test.dtd">'</span><span class="p">))</span>
353 <span class="go"><!DOCTYPE root SYSTEM "/tmp/test.dtd"></span>
354 <span class="go"><root/></span>
356 <p>The content will be encoded, but otherwise copied verbatim into the
357 output stream. It is therefore left to the user to take care for a
358 correct doctype format, including the name of the root node.</p>
361 <div class="section" id="incremental-xml-generation">
362 <h1>Incremental XML generation</h1>
363 <p>Since version 3.1, lxml provides an <tt class="docutils literal">xmlfile</tt> API for incrementally
364 generating XML using the <tt class="docutils literal">with</tt> statement. It's main purpose is to
365 freely and safely mix surrounding elements with pre-built in-memory
366 trees, e.g. to write out large documents that consist mostly of
367 repetitive subtrees (like database dumps). But it can be useful in
368 many cases where memory consumption matters or where XML is naturally
369 generated in sequential steps. Since lxml 3.4.1, there is an equivalent
370 context manager for HTML serialisation called <tt class="docutils literal">htmlfile</tt>.</p>
371 <p>The API can serialise to real files (given as file path or file
372 object), as well as file-like objects, e.g. <tt class="docutils literal">io.BytesIO()</tt>.
373 Here is a simple example:</p>
374 <pre class="literal-block">
375 >>> f = BytesIO()
376 >>> with etree.xmlfile(f) as xf:
377 ... with xf.element('abc'):
380 >>> print(f.getvalue().decode('utf-8'))
381 <abc>text</abc>
383 <p><tt class="docutils literal">xmlfile()</tt> accepts a file path as first argument, or a file(-like)
384 object, as in the example above. In the first case, it takes care to
385 open and close the file itself, whereas file(-like) objects are not
386 closed by default. This is left to the code that opened them. Since
387 lxml 3.4, however, you can pass the argument <tt class="docutils literal">close=True</tt> to make
388 lxml call the object's <tt class="docutils literal">.close()</tt> method when exiting the xmlfile
390 <p>To insert pre-constructed Elements and subtrees, just pass them
391 into <tt class="docutils literal">write()</tt>:</p>
392 <pre class="literal-block">
393 >>> f = BytesIO()
394 >>> with etree.xmlfile(f) as xf:
395 ... with xf.element('abc'):
396 ... with xf.element('in'):
398 ... for value in '123':
399 ... # construct a really complex XML tree
400 ... el = etree.Element('xyz', attr=value)
404 ... # no longer needed, discard it right away!
407 >>> print(f.getvalue().decode('utf-8'))
408 <abc><in><xyz attr="1"/><xyz attr="2"/><xyz attr="3"/></in></abc>
410 <p>It is a common pattern to have one or more nested <tt class="docutils literal">element()</tt>
411 blocks, and then build in-memory XML subtrees in a loop (using the
412 ElementTree API, the builder API, XSLT, or whatever) and write them
413 out into the XML file one after the other. That way, they can be
414 removed from memory right after their construction, which can largely
415 reduce the memory footprint of an application, while keeping the
416 overall XML generation easy, safe and correct.</p>
417 <p>Together with Python coroutines, this can be used to generate XML
418 in an asynchronous, non-blocking fashion, e.g. for a stream protocol
419 like the instant messaging protocol
420 <a class="reference external" href="https://en.wikipedia.org/wiki/Extensible_Messaging_and_Presence_Protocol">XMPP</a>:</p>
421 <pre class="literal-block">
422 def writer(out_stream):
423 with xmlfile(out_stream) as xf:
424 with xf.element('{http://etherx.jabber.org/streams}stream'):
431 next(w) # start writing (run up to 'yield')
433 <p>Then, whenever XML elements are available for writing, call</p>
434 <pre class="literal-block">
437 <p>And when done:</p>
438 <pre class="literal-block">
441 <p>Note the additional <tt class="docutils literal">xf.flush()</tt> call in the example above, which is
442 available since lxml 3.4. Normally, the output stream is buffered to
443 avoid excessive I/O calls. Whenever the internal buffer fills up, its
444 content is written out. In the case above, however, we want to make
445 sure that each message that we write (i.e. each element subtree) is
446 written out immediately, so we flush the content explicitly at the
448 <p>Alternatively, if buffering is not desired at all, it can be disabled
449 by passing the flag <tt class="docutils literal">buffered=False</tt> into <tt class="docutils literal">xmlfile()</tt> (also since
451 <p>Here is a similar example using an async coroutine in Py3.5 or later, which is
452 supported since lxml 4.0. The output stream is expected to have methods
453 <tt class="docutils literal">async def write(self, data)</tt> and <tt class="docutils literal">async def close(self)</tt> in this case.</p>
454 <pre class="literal-block">
455 async def writer(out_stream, xml_messages):
456 async with xmlfile(out_stream) as xf:
457 async with xf.element('{http://etherx.jabber.org/streams}stream'):
458 async for el in xml_messages:
463 class DummyAsyncOut(object):
464 async def write(self, data):
465 print(data.decode('utf8'))
467 async def close(self):
470 stream = DummyAsyncOut()
471 async_writer = writer(stream, async_message_stream)
474 <div class="section" id="cdata">
476 <p>By default, lxml's parser will strip CDATA sections from the tree and
477 replace them by their plain text content. As real applications for
478 CDATA are rare, this is the best way to deal with this issue.</p>
479 <p>However, in some cases, keeping CDATA sections or creating them in a
480 document is required to adhere to existing XML language definitions.
481 For these special cases, you can instruct the parser to leave CDATA
482 sections in the document:</p>
483 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">parser</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">XMLParser</span><span class="p">(</span><span class="n">strip_cdata</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
484 <span class="gp">>>> </span><span class="n">root</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">XML</span><span class="p">(</span><span class="s1">'<root><![CDATA[test]]></root>'</span><span class="p">,</span> <span class="n">parser</span><span class="p">)</span>
485 <span class="gp">>>> </span><span class="n">root</span><span class="o">.</span><span class="n">text</span>
486 <span class="go">'test'</span>
488 <span class="gp">>>> </span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">root</span><span class="p">)</span>
489 <span class="go">b'<root><![CDATA[test]]></root>'</span>
491 <p>Note how the <tt class="docutils literal">.text</tt> property does not give any indication that the
492 text content is wrapped by a CDATA section. If you want to make sure
493 your data is wrapped by a CDATA block, you can use the <tt class="docutils literal">CDATA()</tt>
495 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">root</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="s1">'test'</span>
497 <span class="gp">>>> </span><span class="n">root</span><span class="o">.</span><span class="n">text</span>
498 <span class="go">'test'</span>
499 <span class="gp">>>> </span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">root</span><span class="p">)</span>
500 <span class="go">b'<root>test</root>'</span>
502 <span class="gp">>>> </span><span class="n">root</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">CDATA</span><span class="p">(</span><span class="n">root</span><span class="o">.</span><span class="n">text</span><span class="p">)</span>
504 <span class="gp">>>> </span><span class="n">root</span><span class="o">.</span><span class="n">text</span>
505 <span class="go">'test'</span>
506 <span class="gp">>>> </span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">root</span><span class="p">)</span>
507 <span class="go">b'<root><![CDATA[test]]></root>'</span>
510 <div class="section" id="xinclude-and-elementinclude">
511 <h1>XInclude and ElementInclude</h1>
512 <p>You can let lxml process xinclude statements in a document by calling the
513 xinclude() method on a tree:</p>
514 <div class="syntax"><pre><span></span><span class="gp">>>> </span><span class="n">data</span> <span class="o">=</span> <span class="n">StringIO</span><span class="p">(</span><span class="s1">'''</span><span class="se">\</span>
515 <span class="gp">... </span><span class="s1"><doc xmlns:xi="http://www.w3.org/2001/XInclude"></span>
516 <span class="gp">... </span><span class="s1"><foo/></span>
517 <span class="gp">... </span><span class="s1"><xi:include href="doc/test.xml" /></span>
518 <span class="gp">... </span><span class="s1"></doc>'''</span><span class="p">)</span>
520 <span class="gp">>>> </span><span class="n">tree</span> <span class="o">=</span> <span class="n">etree</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
521 <span class="gp">>>> </span><span class="n">tree</span><span class="o">.</span><span class="n">xinclude</span><span class="p">()</span>
522 <span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">etree</span><span class="o">.</span><span class="n">tostring</span><span class="p">(</span><span class="n">tree</span><span class="o">.</span><span class="n">getroot</span><span class="p">()))</span>
523 <span class="go"><doc xmlns:xi="http://www.w3.org/2001/XInclude"></span>
524 <span class="go"><foo/></span>
525 <span class="go"><a xml:base="doc/test.xml"/></span>
526 <span class="go"></doc></span>
528 <p>Note that the ElementTree compatible <a class="reference external" href="http://effbot.org/zone/element-xinclude.htm">ElementInclude</a> module is also supported
529 as <tt class="docutils literal">lxml.ElementInclude</tt>. It has the additional advantage of supporting
530 custom <a class="reference external" href="resolvers.html">URL resolvers</a> at the Python level. The normal XInclude mechanism
531 cannot deploy these. If you need ElementTree compatibility or custom
532 resolvers, you have to stick to the external Python module.</p>
536 <hr class="footer" />
537 Generated on: 2020-10-17.
projects / platform / upstream / python-lxml.git / blob