~ubuntu-branches/ubuntu/saucy/lxml/saucy-updates

To make the access to these subelements as easy and straight forward as

possible, elements behave like normal Python lists:

    >>> root[0] = root[-1] # this moves the element in lxml.etree!

    >>> for child in root:

    ...     print(child.tag)

    child3

    child1

    child2

 

an Element to see if it has children, i.e. if the list of children is empty.

This is no longer supported as people tend to find it surprising that a

non-None reference to an existing Element can evaluate to False.  Instead, use

``len(element)``, which is both more explicit and less error prone.

 

Note in the examples that the last element was *moved* to a different position

in the last example.  This is a difference from the original ElementTree (and

from lists), where elements can sit in multiple positions of any number of

trees.  In lxml.etree, elements can only sit in one position of one tree at a

time.

 

If you want to *copy* an element to a different position, consider creating an

independent *deep copy* using the ``copy`` module from Python's standard

library:

The way up in the tree is provided through the ``getparent()`` method:

 

.. sourcecode:: pycon

 

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

    True

 

Elements carry attributes

-------------------------

Fast and direct access to these attributes is provided by the ``set()`` and

``get()`` methods of elements:

    >>> root.set("interesting", "somewhat")

    >>> print(root.get("interesting"))

    somewhat

 

However, a very convenient way of dealing with them is through the dictionary

interface of the ``attrib`` property:

    somewhat

 

    >>> print(attributes.get("hello"))

    >>> print(attributes.get("hello"))

``iter()`` to have it filter for you.  Since lxml 3.0, you can also pass more

than one tag to intercept on multiple tags during iteration.

Since lxml 2.0 (and ElementTree 1.3), the serialisation functions can

do more than XML serialisation.  You can serialise to HTML or extract

the text content by passing the ``method`` keyword:

character encodings`_.

 

.. _`article about the Unicode character set and character encodings`: http://www.w3.org/International/tutorials/tutorial-char-enc/

root node.  It provides a couple of methods for parsing, serialisation

and general document handling.  One of the bigger differences is that

it serialises as a complete document, as opposed to a single

``Element``.  This includes top-level processing instructions and

comments, as well as a DOCTYPE and other DTD content in the document:

    >>> tree = etree.parse(StringIO('''\

    ... <!DOCTYPE root SYSTEM "test" [ <!ENTITY tasty "eggs"> ]>

    ... '''))

    >>> # lxml 1.3.4 and later

    >>> print(etree.tostring(tree))

    <!DOCTYPE root SYSTEM "test" [

    <!ENTITY tasty "eggs">

    ]>

    <root>

      <a>eggs</a>

    </root>

 

    >>> # lxml 1.3.4 and later

    >>> print(etree.tostring(etree.ElementTree(tree.getroot())))

    <!DOCTYPE root SYSTEM "test" [

    <!ENTITY tasty "eggs">

    ]>

    <root>

      <a>eggs</a>

    </root>

 

    >>> # ElementTree and lxml <= 1.3.3

      <a>eggs</a>

Note that this has changed in lxml 1.3.4 to match the behaviour of

lxml 2.0.  Before, the examples were serialised without DTD content,

which made lxml loose DTD information in an input-output cycle.

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

    >>> some_file_like = StringIO("<root>data</root>")

    >>> tree = etree.parse(some_file_like)

open file.

The ElementTree API avoids `namespace prefixes`_ wherever possible and deploys

the real namespaces instead:

.. _`namespace prefixes`: http://www.w3.org/TR/xml-names/#ns-qualnames

 

The notation that ElementTree uses was originally brought up by `James

Clark`_.  It has the major advantage of providing a universally

qualified name for a tag, regardless of any prefixes that may or may

not have been used or defined in a document.  By moving the

indirection of prefixes out of the way, it makes namespace aware code

much clearer and safer.

 

.. _`James Clark`: http://www.jclark.com/xml/xmlns.htm

Namespaces on attributes work alike, but since version 2.3, lxml.etree