The lxml.etree Tutorial (2024)

• lxml
  • lxml
    • Introduction
    • Support the project
    • Documentation
    • Download
    • Mailing list
    • Bug tracker
    • License
    • Old Versions
    • Project income report
    • Legal Notice for Donations
  • Why lxml?
    • Motto
    • Aims
  • Installing lxml
    • Where to get it
    • Requirements
    • Installation
    • Building lxml from dev sources
    • Using lxml with python-libxml2
    • Source builds on MS Windows
    • Source builds on MacOS-X
  • Benchmarks and Speed
    • General notes
    • How to read the timings
    • Parsing and Serialising
    • The ElementTree API
    • XPath
    • A longer example
    • lxml.objectify
  • ElementTree compatibility of lxml.etree
  • lxml FAQ - Frequently Asked Questions
    • General Questions
    • Installation
    • Contributing
    • Bugs
    • Threading
    • Parsing and Serialisation
    • XPath and Document Traversal

• Developing with lxml
  • The lxml.etree Tutorial
    • The Element class
    • The ElementTree class
    • Parsing from strings and files
    • Namespaces
    • The E-factory
    • ElementPath
  • API reference
  • APIs specific to lxml.etree
    • lxml.etree
    • Other Element APIs
    • Trees and Documents
    • Iteration
    • Error handling on exceptions
    • Error logging
    • Serialisation
    • Incremental XML generation
    • CDATA
    • XInclude and ElementInclude
  • Parsing XML and HTML with lxml
    • Parsers
    • The target parser interface
    • The feed parser interface
    • Incremental event parsing
    • iterparse and iterwalk
    • Python unicode strings
  • Validation with lxml
    • Validation at parse time
    • DTD
    • RelaxNG
    • XMLSchema
    • Schematron
    • (Pre-ISO-Schematron)
  • XPath and XSLT with lxml
    • XPath
    • XSLT
  • lxml.objectify
    • The lxml.objectify API
    • Asserting a Schema
    • ObjectPath
    • Python data types
    • How data types are matched
    • What is different from lxml.etree?
  • lxml.html
    • Parsing HTML
    • HTML Element Methods
    • Running HTML doctests
    • Creating HTML with the E-factory
    • Working with links
    • Forms
    • HTML Diff
    • Examples
  • lxml.cssselect
    • The CSSSelector class
    • The cssselect method
    • Supported Selectors
    • Namespaces
  • BeautifulSoup Parser
    • Parsing with the soupparser
    • Entity handling
    • Using soupparser as a fallback
    • Using only the encoding detection
  • html5lib Parser
    • Differences to regular HTML parsing
    • Function Reference

• Extending lxml
  • Document loading and URL resolving
    • XML Catalogs
    • URI Resolvers
    • Document loading in context
    • I/O access control in XSLT
  • Python extensions for XPath and XSLT
    • XPath Extension functions
    • XSLT extension elements
  • Using custom Element classes in lxml
    • Background on Element proxies
    • Element initialization
    • Setting up a class lookup scheme
    • Generating XML with custom classes
    • Implementing namespaces
  • Sax support
    • Building a tree from SAX events
    • Producing SAX events from an ElementTree or Element
    • Interfacing with pulldom/minidom
  • The public C-API of lxml.etree
    • Passing generated trees through Python
    • Writing external modules in Cython
    • Writing external modules in C

• Developing lxml
  • How to build lxml from source
    • Cython
    • Github, git and hg
    • Building the sources
    • Running the tests and reporting errors
    • Building an egg or wheel
    • Building lxml on MacOS-X
    • Static linking on Windows
    • Building Debian packages from SVN sources
  • How to read the source of lxml
    • What is Cython?
    • Where to start?
    • lxml.etree
    • Python modules
    • lxml.objectify
    • lxml.html
  • Release Changelog
  • Credits
    • Main contributors
    • Special thanks goes to:
• Sitemap

Like the tool? Help making it better! Your donation helps!

>>> root = etree.Element("root")

>>> print(root.tag)root

>>> root.append( etree.Element("child1") )

>>> child2 = etree.SubElement(root, "child2")>>> child3 = etree.SubElement(root, "child3")

>>> etree.tostring(root)b'<root><child1/><child2/><child3/></root>'

Elements are lists

To make the access to these subelements easy and straight forward,elements mimic the behaviour of normal Python lists as closely aspossible:

>>> child = root[0]>>> print(child.tag)child1>>> print(len(root))3>>> root.index(root[1]) # lxml.etree only!1>>> children = list(root)>>> for child in root:...  print(child.tag)child1child2child3>>> root.insert(0, etree.Element("child0"))>>> start = root[:1]>>> end = root[-1:]>>> print(start[0].tag)child0>>> print(end[0].tag)child3

Prior to ElementTree 1.3 and lxml 2.0, you could also check the truth value ofan Element to see if it has children, i.e. if the list of children is empty:

if root: # this no longer works! print("The root element has children")

This is no longer supported as people tend to expect that a "something"evaluates to True and expect Elements to be "something", may they havechildren or not. So, many users find it surprising that any Elementwould evaluate to False in an if-statement like the above. Instead,use len(element), which is both more explicit and less error prone.

>>> print(etree.iselement(root)) # test if it's some kind of ElementTrue>>> if len(root): # test if it has children...  print("The root element has children")The root element has children

There is another important case where the behaviour of Elements in lxml(in 2.0 and later) deviates from that of lists and from that of theoriginal ElementTree (prior to version 1.3 or Python 2.7/3.2):

>>> for child in root:...  print(child.tag)child0child1child2child3>>> root[0] = root[-1] # this moves the element in lxml.etree!>>> for child in root:...  print(child.tag)child3child1child2

In this example, the last element is moved to a different position,instead of being copied, i.e. it is automatically removed from itsprevious position when it is put in a different place. In lists,objects can appear in multiple positions at the same time, and theabove assignment would just copy the item reference into the firstposition, so that both contain the exact same item:

>>> l = [0, 1, 2, 3]>>> l[0] = l[-1]>>> l[3, 1, 2, 3]

Note that in the original ElementTree, a single Element object can sitin any number of places in any number of trees, which allows for the samecopy operation as with lists. The obvious drawback is that modificationsto such an Element will apply to all places where it appears in a tree,which may or may not be intended.

The upside of this difference is that an Element in lxml.etree alwayshas exactly one parent, which can be queried through the getparent()method. This is not supported in the original ElementTree.

>>> root is root[0].getparent() # lxml.etree only!True

If you want to copy an element to a different position in lxml.etree,consider creating an independent deep copy using the copy modulefrom Python's standard library:

>>> from copy import deepcopy>>> element = etree.Element("neu")>>> element.append( deepcopy(root[1]) )>>> print(element[0].tag)child1>>> print([ c.tag for c in root ])['child3', 'child1', 'child2']

The siblings (or neighbours) of an element are accessed as next and previouselements:

>>> root[0] is root[1].getprevious() # lxml.etree only!True>>> root[1] is root[0].getnext() # lxml.etree only!True

Elements carry attributes as a dict

XML elements support attributes. You can create them directly in the Elementfactory:

>>> root = etree.Element("root", interesting="totally")>>> etree.tostring(root)b'<root interesting="totally"/>'

Attributes are just unordered name-value pairs, so a very convenient wayof dealing with them is through the dictionary-like interface of Elements:

>>> print(root.get("interesting"))totally>>> print(root.get("hello"))None>>> root.set("hello", "Huhu")>>> print(root.get("hello"))Huhu>>> etree.tostring(root)b'<root interesting="totally" hello="Huhu"/>'>>> sorted(root.keys())['hello', 'interesting']>>> for name, value in sorted(root.items()):...  print('%s = %r' % (name, value))hello = 'Huhu'interesting = 'totally'

For the cases where you want to do item lookup or have other reasons forgetting a 'real' dictionary-like object, e.g. for passing it around,you can use the attrib property:

>>> attributes = root.attrib>>> print(attributes["interesting"])totally>>> print(attributes.get("no-such-attribute"))None>>> attributes["hello"] = "Guten Tag">>> print(attributes["hello"])Guten Tag>>> print(root.get("hello"))Guten Tag

Note that attrib is a dict-like object backed by the Element itself.This means that any changes to the Element are reflected in attriband vice versa. It also means that the XML tree stays alive in memoryas long as the attrib of one of its Elements is in use. To get anindependent snapshot of the attributes that does not depend on the XMLtree, copy it into a dict:

>>> d = dict(root.attrib)>>> sorted(d.items())[('hello', 'Guten Tag'), ('interesting', 'totally')]

Elements contain text

Elements can contain text:

>>> root = etree.Element("root")>>> root.text = "TEXT">>> print(root.text)TEXT>>> etree.tostring(root)b'<root>TEXT</root>'

In many XML documents (data-centric documents), this is the only place wheretext can be found. It is encapsulated by a leaf tag at the very bottom of thetree hierarchy.

However, if XML is used for tagged text documents such as (X)HTML, text canalso appear between different elements, right in the middle of the tree:

<html><body>Hello<br/>World</body></html>

Here, the <br/> tag is surrounded by text. This is often referred to asdocument-style or mixed-content XML. Elements support this through theirtail property. It contains the text that directly follows the element, upto the next element in the XML tree:

>>> html = etree.Element("html")>>> body = etree.SubElement(html, "body")>>> body.text = "TEXT">>> etree.tostring(html)b'<html><body>TEXT</body></html>'>>> br = etree.SubElement(body, "br")>>> etree.tostring(html)b'<html><body>TEXT<br/></body></html>'>>> br.tail = "TAIL">>> etree.tostring(html)b'<html><body>TEXT<br/>TAIL</body></html>'

The two properties .text and .tail are enough to represent anytext content in an XML document. This way, the ElementTree API doesnot require any special text nodes in addition to the Elementclass, that tend to get in the way fairly often (as you might knowfrom classic DOM APIs).

However, there are cases where the tail text also gets in the way.For example, when you serialise an Element from within the tree, youdo not always want its tail text in the result (although you wouldstill want the tail text of its children). For this purpose, thetostring() function accepts the keyword argument with_tail:

>>> etree.tostring(br)b'<br/>TAIL'>>> etree.tostring(br, with_tail=False) # lxml.etree only!b'<br/>'

If you want to read only the text, i.e. without any intermediatetags, you have to recursively concatenate all text and tailattributes in the correct order. Again, the tostring() functioncomes to the rescue, this time using the method keyword:

>>> etree.tostring(html, method="text")b'TEXTTAIL'

Using XPath to find text

Another way to extract the text content of a tree is XPath, whichalso allows you to extract the separate text chunks into a list:

>>> print(html.xpath("string()")) # lxml.etree only!TEXTTAIL>>> print(html.xpath("//text()")) # lxml.etree only!['TEXT', 'TAIL']

If you want to use this more often, you can wrap it in a function:

>>> build_text_list = etree.XPath("//text()") # lxml.etree only!>>> print(build_text_list(html))['TEXT', 'TAIL']

Note that a string result returned by XPath is a special 'smart'object that knows about its origins. You can ask it where it camefrom through its getparent() method, just as you would withElements:

>>> texts = build_text_list(html)>>> print(texts[0])TEXT>>> parent = texts[0].getparent()>>> print(parent.tag)body>>> print(texts[1])TAIL>>> print(texts[1].getparent().tag)br

You can also find out if it's normal text content or tail text:

>>> print(texts[0].is_text)True>>> print(texts[1].is_text)False>>> print(texts[1].is_tail)True

While this works for the results of the text() function, lxml willnot tell you the origin of a string value that was constructed by theXPath functions string() or concat():

>>> stringify = etree.XPath("string()")>>> print(stringify(html))TEXTTAIL>>> print(stringify(html).getparent())None

Tree iteration

For problems like the above, where you want to recursively traverse the treeand do something with its elements, tree iteration is a very convenientsolution. Elements provide a tree iterator for this purpose. It yieldselements in document order, i.e. in the order their tags would appear if youserialised the tree to XML:

>>> root = etree.Element("root")>>> etree.SubElement(root, "child").text = "Child 1">>> etree.SubElement(root, "child").text = "Child 2">>> etree.SubElement(root, "another").text = "Child 3">>> prettyprint(root)<root> <child>Child 1</child> <child>Child 2</child> <another>Child 3</another></root>>>> for element in root.iter():...  print(f"{element.tag} - {element.text}")root - Nonechild - Child 1child - Child 2another - Child 3

If you know you are only interested in a single tag, you can pass its name toiter() to have it filter for you. Starting with lxml 3.0, you can alsopass more than one tag to intercept on multiple tags during iteration.

>>> for element in root.iter("child"):...  print(f"{element.tag} - {element.text}")child - Child 1child - Child 2>>> for element in root.iter("another", "child"):...  print(f"{element.tag} - {element.text}")child - Child 1child - Child 2another - Child 3

By default, iteration yields all nodes in the tree, includingProcessingInstructions, Comments and Entity instances. If you want tomake sure only Element objects are returned, you can pass theElement factory as tag parameter:

>>> root.append(etree.Entity("#234"))>>> root.append(etree.Comment("some comment"))>>> for element in root.iter():...  if isinstance(element.tag, str):...  print(f"{element.tag} - {element.text}")...  else:...  print(f"SPECIAL: {element} - {element.text}")root - Nonechild - Child 1child - Child 2another - Child 3SPECIAL: &#234; - &#234;SPECIAL: <!--some comment--> - some comment>>> for element in root.iter(tag=etree.Element):...  print(f"{element.tag} - {element.text}")root - Nonechild - Child 1child - Child 2another - Child 3>>> for element in root.iter(tag=etree.Entity):...  print(element.text)&#234;

Note that passing a wildcard "*" tag name will also yield allElement nodes (and only elements).

In lxml.etree, elements provide further iterators for all directions in thetree: children, parents (or rather ancestors) and siblings.

Serialisation

Serialisation commonly uses the tostring() function that returns astring, or the ElementTree.write() method that writes to a file, afile-like object, or a URL (via FTP PUT or HTTP POST). Both calls acceptthe same keyword arguments like pretty_print for formatted outputor encoding to select a specific output encoding other than plainASCII:

>>> root = etree.XML('<root><a><b/></a></root>')>>> etree.tostring(root)b'<root><a><b/></a></root>'>>> xml_string = etree.tostring(root, xml_declaration=True)>>> print(xml_string.decode(), end='')<?xml version='1.0' encoding='ASCII'?><root><a><b/></a></root>>>> latin1_bytesstring = etree.tostring(root, encoding='iso8859-1')>>> print(latin1_bytesstring.decode('iso8859-1'), end='')<?xml version='1.0' encoding='iso8859-1'?><root><a><b/></a></root>>>> print(etree.tostring(root, pretty_print=True).decode(), end='')<root> <a> <b/> </a></root>

Note that pretty printing appends a newline at the end.We therefore use the end='' option here to prevent the print()function from adding another line break.

For more fine-grained control over the pretty-printing, you can addwhitespace indentation to the tree before serialising it, using theindent() function (added in lxml 4.5):

>>> root = etree.XML('<root><a><b/>\n</a></root>')>>> print(etree.tostring(root).decode())<root><a><b/></a></root>>>> etree.indent(root)>>> print(etree.tostring(root).decode())<root> <a> <b/> </a></root>>>> root.text'\n '>>> root[0].text'\n '>>> etree.indent(root, space=" ")>>> print(etree.tostring(root).decode())<root> <a> <b/> </a></root>>>> etree.indent(root, space="\t")>>> etree.tostring(root)b'<root>\n\t<a>\n\t\t<b/>\n\t</a>\n</root>'

In lxml 2.0 and later, as well as in xml.etree, the serialisationfunctions can do more than XML serialisation. You can serialise toHTML or extract the text content by passing the method keyword:

>>> root = etree.XML(...  '<html><head/><body><p>Hello<br/>World</p></body></html>')>>> etree.tostring(root) # default: method = 'xml'b'<html><head/><body><p>Hello<br/>World</p></body></html>'>>> etree.tostring(root, method='xml') # same as aboveb'<html><head/><body><p>Hello<br/>World</p></body></html>'>>> etree.tostring(root, method='html')b'<html><head></head><body><p>Hello<br>World</p></body></html>'>>> prettyprint(root, method='html')<html><head></head><body><p>Hello<br>World</p></body></html>>>> etree.tostring(root, method='text')b'HelloWorld'

As for XML serialisation, the default encoding for plain textserialisation is ASCII:

>>> br = next(root.iter('br')) # get first result of iteration>>> br.tail = 'Wörld'>>> etree.tostring(root, method='text') # doctest: +ELLIPSISTraceback (most recent call last): ...UnicodeEncodeError: 'ascii' codec can't encode character '\xf6' ...>>> etree.tostring(root, method='text', encoding="UTF-8")b'HelloW\xc3\xb6rld'

Here, serialising to a Python text string instead of a byte stringmight become handy. Just pass the name 'unicode' as encoding:

>>> etree.tostring(root, encoding='unicode', method='text')'HelloWörld'>>> etree.tostring(root, encoding='unicode')'<html><head/><body><p>Hello<br/>Wörld</p></body></html>'

The W3C has a good article about the Unicode character set and character encodings<http://www.w3.org/International/tutorials/tutorial-char-enc/>`_.

>>> root = etree.XML('''\... <?xml version="1.0"?>... <!DOCTYPE root SYSTEM "test" [ <!ENTITY tasty "parsnips"> ]>... <root>...  <a>&tasty;</a>... </root>... ''')>>> tree = etree.ElementTree(root)>>> print(tree.docinfo.xml_version)1.0>>> print(tree.docinfo.doctype)<!DOCTYPE root SYSTEM "test">>>> tree.docinfo.public_id = '-//W3C//DTD XHTML 1.0 Transitional//EN'>>> tree.docinfo.system_url = 'file://local.dtd'>>> print(tree.docinfo.doctype)<!DOCTYPE root PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "file://local.dtd">

>>> prettyprint(tree) # lxml 1.3.4 and later<!DOCTYPE root PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "file://local.dtd" [<!ENTITY tasty "parsnips">]><root> <a>parsnips</a></root>

>>> prettyprint(tree.getroot())<root> <a>parsnips</a></root>

The fromstring() function

The fromstring() function is the easiest way to parse a string:

>>> some_xml_data = "<root>data</root>">>> root = etree.fromstring(some_xml_data)>>> print(root.tag)root>>> etree.tostring(root)b'<root>data</root>'

The XML() function

The XML() function behaves like the fromstring() function, but iscommonly used to write XML literals right into the source:

>>> root = etree.XML("<root>data</root>")>>> print(root.tag)root>>> etree.tostring(root)b'<root>data</root>'

There is also a corresponding function HTML() for HTML literals.

>>> root = etree.HTML("<p>data</p>")>>> etree.tostring(root)b'<html><body><p>data</p></body></html>'

The parse() function

The parse() function is used to parse from files and file-like objects.

As an example of such a file-like object, the following code uses theBytesIO class for reading from a string instead of an external file.However, in real life, you would obviously avoid doing this and use thestring parsing functions like fromstring() above.

>>> from io import BytesIO>>> some_file_or_file_like_object = BytesIO(b"<root>data</root>")>>> tree = etree.parse(some_file_or_file_like_object)>>> etree.tostring(tree)b'<root>data</root>'

Note that parse() returns an ElementTree object, not an Element object asthe string parser functions:

>>> root = tree.getroot()>>> print(root.tag)root>>> etree.tostring(root)b'<root>data</root>'

The reasoning behind this difference is that parse() returns acomplete document from a file, while the string parsing functions arecommonly used to parse XML fragments.

The parse() function supports any of the following sources:

• an open file object (make sure to open it in binary mode)
• a file-like object that has a .read(byte_count) method returninga byte string on each call
• a filename string
• an HTTP or FTP URL string

Note that passing a filename or URL is usually faster than passing anopen file or file-like object. However, the HTTP/FTP client in libxml2is rather simple, so things like HTTP authentication require a dedicatedURL request library, e.g. urllib2 or requests. These librariesusually provide a file-like object for the result that you can parsefrom while the response is streaming in.

Parser objects

By default, lxml.etree uses a standard parser with a default setup. Ifyou want to configure the parser, you can create a new instance:

>>> parser = etree.XMLParser(remove_blank_text=True) # lxml.etree only!

This creates a parser that removes empty text between tags while parsing,which can reduce the size of the tree and avoid dangling tail text if you knowthat whitespace-only content is not meaningful for your data. An example:

>>> root = etree.XML("<root> <a/> <b> </b> </root>", parser)>>> etree.tostring(root)b'<root><a/><b> </b></root>'

Note that the whitespace content inside the <b> tag was not removed, ascontent at leaf elements tends to be data content (even if blank). You caneasily remove it in an additional step by traversing the tree:

>>> for element in root.iter("*"):...  if element.text is not None and not element.text.strip():...  element.text = None>>> etree.tostring(root)b'<root><a/><b/></root>'

See help(etree.XMLParser) to find out about the available parser options.

Incremental parsing

lxml.etree provides two ways for incremental step-by-step parsing. One isthrough file-like objects, where it calls the read() method repeatedly.This is best used where the data arrives from a source like urllib or anyother file-like object that can provide data on request. Note that the parserwill block and wait until data becomes available in this case:

>>> class DataSource:...  data = [ b"<roo", b"t><", b"a/", b"><", b"/root>" ]...  def read(self, requested_size):...  try:...  return self.data.pop(0)...  except IndexError:...  return b''>>> tree = etree.parse(DataSource())>>> etree.tostring(tree)b'<root><a/></root>'

The second way is through a feed parser interface, given by the feed(data)and close() methods:

>>> parser = etree.XMLParser()>>> parser.feed("<roo")>>> parser.feed("t><")>>> parser.feed("a/")>>> parser.feed("><")>>> parser.feed("/root>")>>> root = parser.close()>>> etree.tostring(root)b'<root><a/></root>'

Here, you can interrupt the parsing process at any time and continue it lateron with another call to the feed() method. This comes in handy if youwant to avoid blocking calls to the parser, e.g. in frameworks like Twisted,or whenever data comes in slowly or in chunks and you want to do other thingswhile waiting for the next chunk.

After calling the close() method (or when an exception was raisedby the parser), you can reuse the parser by calling its feed()method again:

>>> parser.feed("<root/>")>>> root = parser.close()>>> etree.tostring(root)b'<root/>'

Event-driven parsing

Sometimes, all you need from a document is a small fraction somewhere deepinside the tree, so parsing the whole tree into memory, traversing it anddropping it can be too much overhead. lxml.etree supports this use casewith two event-driven parser interfaces, one that generates parser eventswhile building the tree (iterparse), and one that does not build the treeat all, and instead calls feedback methods on a target object in a SAX-likefashion.

Here is a simple iterparse() example:

>>> some_file_like = BytesIO(b"<root><a>data</a></root>")>>> for event, element in etree.iterparse(some_file_like):...  print(f"{event}, {element.tag:>4}, {element.text}")end, a, dataend, root, None

By default, iterparse() only generates an event when it is done parsing anelement, but you can control this through the events keyword argument:

>>> some_file_like = BytesIO(b"<root><a>data</a></root>")>>> for event, element in etree.iterparse(some_file_like,...  events=("start", "end")):...  print(f"{event:>5}, {element.tag:>4}, {element.text}")start, root, Nonestart, a, data end, a, data end, root, None

Note that the text, tail, and children of an Element are not necessarily presentyet when receiving the start event. Only the end event guaranteesthat the Element has been parsed completely.

It also allows you to .clear() or modify the content of an Element tosave memory. So if you parse a large tree and you want to keep memoryusage small, you should clean up parts of the tree that you no longerneed. The keep_tail=True argument to .clear() makes sure that(tail) text content that follows the current element will not be touched.It is highly discouraged to modify any content that the parser may nothave completely read through yet.

>>> some_file_like = BytesIO(...  b"<root><a><b>data</b></a><a><b/></a></root>")>>> for event, element in etree.iterparse(some_file_like):...  if element.tag == 'b':...  print(element.text)...  elif element.tag == 'a':...  print("** cleaning up the subtree")...  element.clear(keep_tail=True)data** cleaning up the subtreeNone** cleaning up the subtree

A very important use case for iterparse() is parsing largegenerated XML files, e.g. database dumps. Most often, these XMLformats only have one main data item element that hangs directly belowthe root node and that is repeated thousands of times. In this case,it is best practice to let lxml.etree do the tree building and only tointercept on exactly this one Element, using the normal tree APIfor data extraction.

>>> xml_file = BytesIO(b'''\... <root>...  <a><b>ABC</b><c>abc</c></a>...  <a><b>MORE DATA</b><c>more data</c></a>...  <a><b>XYZ</b><c>xyz</c></a>... </root>''')>>> for _, element in etree.iterparse(xml_file, tag='a'):...  print('%s -- %s' % (element.findtext('b'), element[1].text))...  element.clear(keep_tail=True)ABC -- abcMORE DATA -- more dataXYZ -- xyz

If, for some reason, building the tree is not desired at all, thetarget parser interface of lxml.etree can be used. It createsSAX-like events by calling the methods of a target object. Byimplementing some or all of these methods, you can control whichevents are generated:

>>> class ParserTarget:...  events = []...  close_count = 0...  def start(self, tag, attrib):...  self.events.append(("start", tag, attrib))...  def close(self):...  events, self.events = self.events, []...  self.close_count += 1...  return events>>> parser_target = ParserTarget()>>> parser = etree.XMLParser(target=parser_target)>>> events = etree.fromstring('<root test="true"/>', parser)>>> print(parser_target.close_count)1>>> for event in events:...  print(f'event: {event[0]} - tag: {event[1]}')...  for attr, value in event[2].items():...  print(f' * {attr} = {value}')event: start - tag: root * test = true

You can reuse the parser and its target as often as you like, so youshould take care that the .close() method really resets thetarget to a usable state (also in the case of an error!).

>>> events = etree.fromstring('<root test="true"/>', parser)>>> print(parser_target.close_count)2>>> events = etree.fromstring('<root test="true"/>', parser)>>> print(parser_target.close_count)3>>> events = etree.fromstring('<root test="true"/>', parser)>>> print(parser_target.close_count)4>>> for event in events:...  print(f'event: {event[0]} - tag: {event[1]}')...  for attr, value in event[2].items():...  print(f' * {attr} = {value}')event: start - tag: root * test = true

>>> xhtml = etree.Element("{http://www.w3.org/1999/xhtml}html")>>> body = etree.SubElement(xhtml, "{http://www.w3.org/1999/xhtml}body")>>> body.text = "Hello World">>> prettyprint(xhtml)<html:html xmlns:html="http://www.w3.org/1999/xhtml"> <html:body>Hello World</html:body></html:html>

>>> XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml">>> XHTML = "{%s}" % XHTML_NAMESPACE>>> NSMAP = {None : XHTML_NAMESPACE} # the default namespace (no prefix)>>> xhtml = etree.Element(XHTML + "html", nsmap=NSMAP) # lxml only!>>> body = etree.SubElement(xhtml, XHTML + "body")>>> body.text = "Hello World">>> prettyprint(xhtml)<html xmlns="http://www.w3.org/1999/xhtml"> <body>Hello World</body></html>

>>> tag = etree.QName('http://www.w3.org/1999/xhtml', 'html')>>> print(tag.localname)html>>> print(tag.namespace)http://www.w3.org/1999/xhtml>>> print(tag.text){http://www.w3.org/1999/xhtml}html>>> tag = etree.QName('{http://www.w3.org/1999/xhtml}html')>>> print(tag.localname)html>>> print(tag.namespace)http://www.w3.org/1999/xhtml>>> root = etree.Element('{http://www.w3.org/1999/xhtml}html')>>> tag = etree.QName(root)>>> print(tag.localname)html>>> tag = etree.QName(root, 'script')>>> print(tag.text){http://www.w3.org/1999/xhtml}script>>> tag = etree.QName('{http://www.w3.org/1999/xhtml}html', 'script')>>> print(tag.text){http://www.w3.org/1999/xhtml}script

>>> xhtml.nsmap{None: 'http://www.w3.org/1999/xhtml'}

>>> root = etree.Element('root', nsmap={'a': 'http://a.b/c'})>>> child = etree.SubElement(root, 'child',...  nsmap={'b': 'http://b.c/d'})>>> len(root.nsmap)1>>> len(child.nsmap)2>>> child.nsmap['a']'http://a.b/c'>>> child.nsmap['b']'http://b.c/d'

>>> body.set(XHTML + "bgcolor", "#CCFFAA")>>> prettyprint(xhtml)<html xmlns="http://www.w3.org/1999/xhtml"> <body xmlns:html="http://www.w3.org/1999/xhtml" html:bgcolor="#CCFFAA">Hello World</body></html>>>> print(body.get("bgcolor"))None>>> body.get(XHTML + "bgcolor")'#CCFFAA'

>>> find_xhtml_body = etree.ETXPath( # lxml only !...  "//{%s}body" % XHTML_NAMESPACE)>>> results = find_xhtml_body(xhtml)>>> print(results[0].tag){http://www.w3.org/1999/xhtml}body

>>> for el in xhtml.iter('*'): print(el.tag) # any element{http://www.w3.org/1999/xhtml}html{http://www.w3.org/1999/xhtml}body>>> for el in xhtml.iter('{http://www.w3.org/1999/xhtml}*'): print(el.tag){http://www.w3.org/1999/xhtml}html{http://www.w3.org/1999/xhtml}body>>> for el in xhtml.iter('{*}body'): print(el.tag){http://www.w3.org/1999/xhtml}body

>>> [ el.tag for el in xhtml.iter('{http://www.w3.org/1999/xhtml}body') ]['{http://www.w3.org/1999/xhtml}body']>>> [ el.tag for el in xhtml.iter('body') ][]>>> [ el.tag for el in xhtml.iter('{}body') ][]>>> [ el.tag for el in xhtml.iter('{}*') ][]

>>> from lxml.builder import E>>> def CLASS(*args): # class is a reserved word in Python...  return {"class":' '.join(args)}>>> html = page = (...  E.html( # create an Element called "html"...  E.head(...  E.title("This is a sample document")...  ),...  E.body(...  E.h1("Hello!", CLASS("title")),...  E.p("This is a paragraph with ", E.b("bold"), " text in it!"),...  E.p("This is another paragraph, with a", "\n ",...  E.a("link", href="http://www.python.org"), "."),...  E.p("Here are some reserved characters: <spam&egg>."),...  etree.XML("<p>And finally an embedded XHTML fragment.</p>"),...  )...  )... )>>> prettyprint(page)<html> <head> <title>This is a sample document</title> </head> <body> <h1 class="title">Hello!</h1> <p>This is a paragraph with <b>bold</b> text in it!</p> <p>This is another paragraph, with a <a href="http://www.python.org">link</a>.</p> <p>Here are some reserved characters: &lt;spam&amp;egg&gt;.</p> <p>And finally an embedded XHTML fragment.</p> </body></html>

>>> from lxml.builder import ElementMaker # lxml only !>>> E = ElementMaker(namespace="http://my.de/fault/namespace",...  nsmap={'p' : "http://my.de/fault/namespace"})>>> DOC = E.doc>>> TITLE = E.title>>> SECTION = E.section>>> PAR = E.par>>> my_doc = DOC(...  TITLE("The dog and the hog"),...  SECTION(...  TITLE("The dog"),...  PAR("Once upon a time, ..."),...  PAR("And then ...")...  ),...  SECTION(...  TITLE("The hog"),...  PAR("Sooner or later ...")...  )... )>>> prettyprint(my_doc)<p:doc xmlns:p="http://my.de/fault/namespace"> <p:title>The dog and the hog</p:title> <p:section> <p:title>The dog</p:title> <p:par>Once upon a time, ...</p:par> <p:par>And then ...</p:par> </p:section> <p:section> <p:title>The hog</p:title> <p:par>Sooner or later ...</p:par> </p:section></p:doc>

>>> root = etree.XML("<root><a x='123'>aText<b/><c/><b/></a></root>")

>>> print(root.find("b"))None>>> print(root.find("a").tag)a

>>> print(root.find(".//b").tag)b>>> [ b.tag for b in root.iterfind(".//b") ]['b', 'b']

>>> print(root.findall(".//a[@x]")[0].tag)a>>> print(root.findall(".//a[@y]"))[]

>>> tree = etree.ElementTree(root)>>> a = root[0]>>> print(tree.getelementpath(a[0]))a/b[1]>>> print(tree.getelementpath(a[1]))a/c>>> print(tree.getelementpath(a[2]))a/b[2]>>> tree.find(tree.getelementpath(a[2])) == a[2]True

>>> print(root.find(".//b").tag)b>>> print(next(root.iterfind(".//b")).tag)b>>> print(next(root.iter("b")).tag)b