Parsing XML with Python's ElementTree

From Text to Structure

When XML data arrives as a plain string, it is only a sequence of characters. You cannot conveniently navigate to a particular piece of information until the string has been transformed into a structure. Python's ElementTree provides the fromstring function for this conversion. It reads the XML string and builds a hierarchical tree whose elements mirror the nesting in the XML.

Building the Element Tree

The fromstring function returns an Element object representing the root element. The root is the entry point to the complete tree. For example, if the outermost tag is person, the returned Element represents person and gives your code access to the nested elements inside it.

import xml.etree.ElementTree as ET xml_data = "<person><name>Ada</name><phone>555-0100</phone></person>" root = ET.fromstring(xml_data) print(root.tag)

person

Finding a Nested Element

After parsing, use the find method to search the tree for a tag name. find returns an Element object for the first matching element. That returned object becomes the specific part of the tree from which you can extract data.

name_element = root.find("name")

if name_element is not None:
    print(name_element.text)

Ada

The check is important. If no element has the requested tag, find returns None. None is not an Element, so attempting to access .text or .get() on it causes the code to fail. Check the result before reading its properties.

Reading Text and Attributes

XML stores information in two distinct places. Text content appears between an element's opening and closing tags and is accessed through .text. Attributes are key-value pairs in the opening tag and are accessed with .get(). An element may have text, attributes, both, or neither.

xml_data = "<person id='p1'><name>Ada</name></person>"
root = ET.fromstring(xml_data)

name_element = root.find("name")
if name_element is not None:
    print(name_element.text)

print(root.get("id"))

Ada
p1

In this example, name_element.text reads the content inside the name tags. In contrast, root.get("id") reads the id attribute from the person opening tag. The two expressions retrieve different kinds of XML data.

Cleaning Extracted Text

The value returned by .text can include whitespace from the original XML. This is especially noticeable when the XML contains newlines and spaces around the content. When clean text is needed, use the string .strip() method after confirming that you have a valid element.

phone_element = root.find("phone")

if phone_element is not None and phone_element.text is not None:
    phone_number = phone_element.text.strip()
    print(phone_number)

Mistakes in XML Extraction

• Using .get() to read element text

  Text content and attributes are separate. .get() accesses an attribute value, not the content between tags.

  Fix: Use name_element.text for content between the opening and closing tags.

• Using .text to read an attribute

  The id value is stored as an attribute in the opening tag, not as the element's text content.

  Fix: Use root.get("id") to retrieve the attribute value.

• Accessing properties without checking find

  If email does not exist, find returns None, and None does not provide a .text property.

  Fix: Check that email_element is not None before accessing .text or .get().

• Treating whitespace as part of the desired value

  The original XML may contribute newlines and spaces to the returned text.

  Fix: Use phone_element.text.strip() when the extracted text needs whitespace removed.

Practice the Extraction Sequence

Key Takeaways

1. ET.fromstring converts an XML string into an Element tree whose root represents the outermost element.
2. find locates the first element with a matching tag name and returns an Element object.
3. Use .text for content between an element's opening and closing tags.
4. Use .get() for attribute values stored in an element's opening tag.
5. Check the result of find before accessing properties, and strip whitespace from text when necessary.