SoFunction
Updated on 2025-04-20

Easily parse XML files with Python

XML files are very common in data processing and configuration storage, but manually parsing them can be a headache. Python provides a variety of simple and efficient ways to process XML files. Today we will talk about this topic in detail. Whether you want to read configuration files, parse web page data, or process API responses, mastering XML parsing can make your work more effective with half the effort!

Why do you need to parse XML files?

XML (Extensible Markup Language) is a commonly used data storage and transmission format. Its structured features make it very suitable for storing configuration information and transmitting complex data. for example:

  • RSS feed for the website
  • Android application layout file
  • Configuration files for various software
  • Web Service API Response

Imagine that you receive an XML file containing hundreds of product information, and manually extracting data is not only time-consuming and error-prone. At this time, Python can show off its skills!

Several ways to parse XML in Python

The Python standard library provides a variety of XML processing methods, and the three most commonly used ones are:

  • DOM parsing: Read the entire XML into memory, suitable for small files
  • SAX parsing: event-driven parsing, suitable for large files
  • ElementTree: Simple and easy-to-use API, suitable for most scenarios

Let's first look at a simple XML file example:

<bookstore>
  <book category="programming">
    <title>PythonGetting started with programming</title>
    <author>Zhang Wei</author>
    <year>2023</year>
    <price>59.99</price>
  </book>
  <book category="design">
    <title>UIDesign Principles</title>
    <author>Li Na</author>
    <year>2022</year>
    <price>49.99</price>
  </book>
</bookstore>

Parsing XML using ElementTree

ElementTree is the most recommended XML parsing method in Python, it is simple and intuitive. Let's see how to parse the above XML using ElementTree:

import  as ET

# parse XML filestree = ('')
root = ()

# traverse all book elementsfor book in ('book'):
    title = ('title').text
    author = ('author').text
    price = ('price').text
    print(f"Book title：{title}，author：{author}，price：{price}")

This code will output:

Book title: Introduction to Python Programming, Author: Zhang Wei, Price: 59.99
Book title: UI design principles, author: Li Na, price: 49.99

Handle XML attributes and namespaces

XML elements often carry attributes, such as the category attribute in the example above. We can get the attribute value like this:

for book in ('book'):
    category = ('category')
    print(f"category：{category}")

When XML contains namespaces, parsing is slightly more complicated. for example:

<ns:bookstore xmlns:ns="/books">
  <ns:book>...</ns:book>
</ns:bookstore>

The processing method is as follows:

# Register a namespaceET.register_namespace('ns', '/books')
# You need to add a namespace prefix when searchingfor book in ('ns:book', {'ns': '/books'}):
    # Process book elements

Enhanced functionality using lxml library

The Python standard library has limited ElementTree features. If you need more powerful features (such as XPath support), you can use the third-party library lxml:

from lxml import etree

tree = ('')
# Use XPath to find all books with prices greater than 50expensive_books = ('//book[price&gt;50]/title/text()')
print(expensive_books)  # Output: ['Beginner of Python Programming']

lxml is faster and more functional than standard libraries, especially suitable for handling large XML files. If you often need to process XML data, it is recommended to install this library:

pip install lxml

Handle special characters and encoding issues

XML files may contain special characters (such as &, <, >), which Python's XML parser will automatically process. But if you need to generate XML manually, remember to use the escape function:

from  import escape

unsafe = '"This" &amp; "That"'
safe = escape(unsafe)
print(safe)  # Output: "This" &amp; "That"

Coding problems are also common. XML files are usually encoded using UTF-8, but sometimes other encodings are encountered. The encoding can be specified during parsing:

with open('', 'r', encoding='gbk') as f:
    tree = (f)

Modify and generate XML files

In addition to parsing, Python can also conveniently modify and generate XML files. For example, we want to increase the price of all books by 10%:

for book in ('book'):
    price = float(('price').text)
    ('price').text = str(price * 1.1)

​​​​​​​# Save the modified file('bookstore_updated.xml')

Generating a new XML file is also very simple:

new_root = ('bookstore')
book = (new_root, 'book', {'category':'novel'})
(book, 'title').text = 'Three-body'
(book, 'author').text = 'Liu Cixin'

# Generate XML stringsxml_str = (new_root, encoding='unicode')
print(xml_str)

Tips in practical application

Handling large XML files: Use the iterparse method to parse large files incrementally to avoid insufficient memory:

for event, elem in ('large_file.xml'):
    if  == 'book':
        # Process book elements        ()  # Clean up processed elements in a timely manner

Verify XML format: You can use the xmlschema library to verify that XML complies with a certain schema:

import xmlschema
schema = ('')
('')

Convert XML to other formats: For example, use pandas to convert XML to DataFrame:

import pandas as pd
df = pd.read_xml('')
print(df)

FAQ

Q: What should I do if I encounter an error while parsing XML?

A: First check whether the XML format is correct, you can use the online XML verification tool. Secondly, confirm whether the encoding is correct, and finally check whether there are special characters that need to be escaped.

Q: Which parsing method has the best performance?

A: For large files, SAX or iterparse mode has the minimum memory footprint; for documents that require frequent query, lxml's XPath performance is the best.

Q: Which is better, XML or JSON?

A: XML is more suitable for document-type data, and JSON is more suitable for data exchange. Most APIs now use JSON, but many traditional systems still use XML.

Summarize

It is actually very simple to parse XML files in Python! With the ElementTree or lxml library, you can easily read, modify and generate XML data. Remember to use incremental parsing when processing large files and register correctly when encountering namespaces. With these skills mastered, XML data processing will no longer be a difficult problem. Go and try these code examples, I believe you will fall in love with the convenience of Python processing XML!

This is the end of this article about using Python to easily parse XML files. For more related content related to Python parsing XML, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!