Accessing Single Elements with find()
findall() returns a Python list of all Element objects matching a given path in the XML tree.
From One Match to Many
When XML contains repeated records, retrieving only one element is not enough. A users list may contain many user records, a product catalog may contain many products, and a weather feed may contain forecasts for several days. The find() method retrieves only the first matching element, while findall() retrieves every matching element as a Python list.
The central distinction is the result: find() gives you one Element object or None when no match exists; findall() gives you a list containing all matching Element objects.
How findall() Builds a List
Picture an XML hierarchy before choosing a path. In the example structure, a users element contains several user elements. Each user element contains child elements such as id and name, and also has an x attribute. The path users/user asks ElementTree to move through the users container and collect every user element it finds.
The result is not one large combined XML value. It is a Python list. Each item in that list represents one complete Element object and therefore represents one user subtree. Because each item is a complete Element object, you can query it for child elements, attributes, or text.
Always check that the path matches the XML hierarchy. If the path is users/user, the XML must have user elements nested inside a users element for those matches to be found. Checking the length of the returned list also confirms how many matches were found.
Processing Each Element
After findall() returns its list, use a for loop to process the elements one at a time. In the loop, the variable item refers to one complete Element object during that iteration. The loop runs once for each item in the list, so every matching XML element gets its own turn.
A generated example would first store the result of root.findall('users/user') in a variable named users. It would then use a for loop with the form for user in users. Inside that loop, user would represent one user Element. The loop could use user.find('name') to locate the name child, user.get('x') to retrieve the x attribute, and the text value of the name element to access its content.
Reading Child Data
Reading names and attributes
Suppose the users container has several user elements. Each user contains a name child element and has an x attribute. How can a loop read both pieces of information for every user?
Collect the users: Call findall() with the path users/user. The result is a Python list containing every matching user Element.
Start the loop: Use a for loop so the loop variable refers to one user Element at a time.
Read the child text: Call find('name') on the current user Element to locate its name child, then access that child element's text content.
Read the attribute: Call get('x') on the current user Element to retrieve the value of its x attribute.
Repeat: When the loop moves to the next list item, the loop variable refers to the next complete user Element, and the same operations can be performed again.
Every matching user can be processed individually, with its child text and attribute accessed from the Element currently held by the loop variable.
The important detail is the level at which each operation is performed. findall() searches from the starting element and creates the collection. The loop selects one user Element from that collection. Then find() searches within that individual user for a child, get() reads an attribute on that user, and .text reads text content from an Element.
Mistakes with Paths and Results
Using find() when every matching element is needed
find() returns only the first matching element, so later matches are not included.
Fix:
Use findall() to obtain a list of all matching elements, then loop through that list.Forgetting that findall() returns a list
The returned value is a collection of Element objects, not one Element object.
Fix:
Loop through the list first. Use .text, find(), or get() on the individual Element held by the loop variable.Using a path that does not match the hierarchy
findall() follows the path supplied, so a mismatched path does not identify the intended elements.
Fix:
Picture the XML hierarchy, adjust the path to match it, and check the length of the returned list.
Practice the Pattern
An XML tree contains a users container with several user elements. Each user has a name child element and an x attribute. Describe the sequence of operations needed to collect every user, visit each user in a loop, read the name text, and read the x attribute.
Hints
- Use findall() with the path users/user to create the collection.
- The loop variable should represent one Element from that collection at a time.
- Use find() for the name child, .text for the child's text content, and get() for the x attribute.
- Check the length of the list if you need to confirm that matches were found.
- The expected pattern is: search with findall(), receive a list, loop through the list, and process each Element using find(), get(), or .text.
Key Takeaways
- find() retrieves only the first matching XML element or None when no match exists.
- findall() follows a path and returns a Python list containing all matching Element objects.
- A for loop processes the returned Elements one at a time.
- Inside the loop, use find() for child elements, get() for attributes, and .text for text content.
- Verify that the path matches the XML hierarchy and check the list length to confirm matches were found.