Parsing XML with Python: A Beginner’s Guide

When working with network automation, you'll frequently encounter XML data - especially from network devices and APIs. Learning XML parsing with Python is essential for any network engineer moving into automation. XML (eXtensible Markup Language) is commonly used in network configuration files, API responses, and device outputs.

What is XML Parsing?

XML parsing is the process of reading XML data and converting it into Python data structures that your scripts can work with. Think of it as translating XML's hierarchical structure into something Python can understand and manipulate.

Here's a typical XML snippet you might see from a network device:

<?xml version="1.0"?>
<interfaces>
    <interface>
        <name>GigabitEthernet0/1</name>
        <ip_address>192.168.1.1</ip_address>
        <subnet_mask>255.255.255.0</subnet_mask>
        <status>up</status>
    </interface>
    <interface>
        <name>GigabitEthernet0/2</name>
        <ip_address>10.0.0.1</ip_address>
        <subnet_mask>255.255.255.0</subnet_mask>
        <status>down</status>
    </interface>
</interfaces>

Python's Built-in XML Parser

Python includes the xml.etree.ElementTree module for XML parsing. This library is perfect for most network automation tasks. Let's see how to use it:

import xml.etree.ElementTree as ET

# Parse XML from a string
xml_data = """
<interfaces>
    <interface>
        <name>GigabitEthernet0/1</name>
        <ip_address>192.168.1.1</ip_address>
        <status>up</status>
    </interface>
</interfaces>
"""

# Create the root element
root = ET.fromstring(xml_data)
print(f"Root tag: {root.tag}")  # Output: interfaces

Extracting Data from XML

Once you have the root element, you can navigate through the XML structure. Here's how to extract interface information:

# Find all interface elements
for interface in root.findall('interface'):
    name = interface.find('name').text
    ip_address = interface.find('ip_address').text
    status = interface.find('status').text
    
    print(f"Interface: {name}")
    print(f"IP Address: {ip_address}")
    print(f"Status: {status}")
    print("-" * 30)

Converting XML to Python Dictionary

For network configuration tasks, you often want to convert XML to Python dictionaries for easier manipulation:

def xml_to_dict(element):
    """Convert XML element to dictionary"""
    result = {}
    
    # Handle element text
    if element.text and element.text.strip():
        return element.text
    
    # Handle child elements
    for child in element:
        child_data = xml_to_dict(child)
        if child.tag in result:
            # Handle multiple elements with same tag
            if not isinstance(result[child.tag], list):
                result[child.tag] = [result[child.tag]]
            result[child.tag].append(child_data)
        else:
            result[child.tag] = child_data
    
    return result

# Convert our interfaces XML to dictionary
interfaces_dict = xml_to_dict(root)
print(interfaces_dict)

Reading XML from Files

In real network automation scenarios, you'll often read XML from files. Here's how:

# Reading from a file
tree = ET.parse('network_config.xml')
root = tree.getroot()

# Or reading from a URL (common with network APIs)
import urllib.request

response = urllib.request.urlopen('http://device-api/interfaces.xml')
xml_content = response.read()
root = ET.fromstring(xml_content)

Handling XML Namespaces

Network device XML often includes namespaces. Here's how to handle them:

# XML with namespace
xml_with_ns = """
<config xmlns="http://example.com/network">
    <interface>
        <name>Gi0/1</name>
    </interface>
</config>
"""

root = ET.fromstring(xml_with_ns)
namespace = {'ns': 'http://example.com/network'}

# Use namespace in find operations
interface = root.find('ns:interface', namespace)
name = interface.find('ns:name', namespace).text
print(f"Interface name: {name}")

Error Handling

Always include error handling when parsing XML in production scripts:

try:
    root = ET.fromstring(xml_data)
    # Your parsing logic here
except ET.ParseError as e:
    print(f"XML parsing error: {e}")
except AttributeError as e:
    print(f"Missing XML element: {e}")

What's Next

Now that you understand XML parsing with Python, you're ready to tackle JSON parsing - another crucial skill for network automation. JSON is even more common in modern network APIs and is often easier to work with than XML.

CCNA Automation study resources

• Cisco Certified DevNet Associate DEVASC 200-901 Official Cert Guide — The official Cisco study guide for automation and programmability. Covers Python, APIs, and network automation fundamentals.