Navigating XML Trees with find and findall

From Repeated XML to Repeated Processing

When XML contains several similar structures, such as multiple users, products, or records, you usually need to process every matching node. The useful pattern is to let findall gather the matching nodes and then use a for loop to process them one at a time. This avoids writing separate extraction statements for each node.

<users>
  <user id="001" x="2">
    <name>Chuck</name>
  </user>
  <user id="009" x="7">
    <name>Brent</name>
  </user>
</users>

This XML has a users container with two user elements. Each user has a name child element and an x attribute. The repeated user structure is what makes findall and a loop useful.

What findall Returns

findall retrieves a Python list containing all XML nodes that match a specified path. In this example, searching for user nodes produces a list with two Element objects. Each Element represents one user node from the XML. The result is therefore a collection of nodes, not one individual node.

lst = root.findall("user")

lst contains two Element objects, one for each user node.

How the Loop Visits Each Node

After findall returns its list, a for loop visits each Element in sequence. The loop variable holds the current XML node. The loop body runs once for each item and stops after all items have been processed.

for item in lst:
    print(item)

On the first iteration, item represents the first user, Chuck, whose id is 001 and whose x attribute is 2. On the second iteration, item represents the second user, Brent, whose id is 009 and whose x attribute is 7. The same loop body runs twice, but item refers to a different Element on each pass.

Reading Child Text and Attributes

An XML node can contain text in a child element and attributes on its opening tag. These two kinds of data use different access patterns. Use find(child_name).text to locate a child element and retrieve the text between its tags. Use get(attribute_name) to retrieve an attribute from the current Element.

for item in lst:
    name = item.find("name").text
    x_value = item.get("x")
    print(name, x_value)

Chuck 2
Brent 7

The expression item.find("name").text first finds the name child inside the current user Element and then reads that child's text. The expression item.get("x") reads the x attribute directly from the current user Element because x is on the user opening tag rather than inside a child element.

Tracing One Complete Pass

Diagnosing Empty or Failing Iterations

• Treating the result of findall as one XML Element

  findall returns a Python list containing matching Element objects. The individual Element is available during each loop iteration.

  Fix: Use the list as the value after in, then call find or get on the loop variable inside the loop.

• Skipping the result check before writing extraction logic

  A path that does not match the XML structure produces a list length of 0, so the loop body has no items to process.

  Fix: Check the list length and inspect the first item immediately after findall.

• Using a path or name with the wrong spelling or capitalization

  The source notes that XML is case-sensitive, so names must match exactly.

  Fix: Compare the path, child-element name, and attribute name with the XML structure.

• Looking for an attribute as though it were a child element

  Child text and attributes are accessed differently. Attributes belong to the current Element.

  Fix: Use item.get("x") for the x attribute and item.find("name").text for the name child text.

1. Check the length of the list returned by findall.
2. Inspect the first item to confirm that findall returned the expected kind of node.
3. If the length is 0, compare the path with the XML structure.
4. If the length is correct but the loop fails, print information about each item inside the loop.
5. Check child-element and attribute names exactly, because XML is case-sensitive.

Practice the Extraction Pattern

for item in lst:
    name = item.find("name").text
    x_value = item.get("x")
    print(name, x_value)

The important structure is the division of responsibility: lst is the collection, item is one Element from that collection, find locates a child within item, text extracts the child's content, and get reads an attribute from item.

Key Takeaways

1. findall returns a Python list of every XML Element matching a path.
2. A for loop assigns one matching Element to its loop variable on each iteration.
3. Use item.find(child_name).text to retrieve text from a child element.
4. Use item.get(attribute_name) to retrieve an attribute from the current Element.
5. When iteration fails, check the list length, inspect an item, and verify names and paths exactly.