5 Best Ways to Create XML Documents Using Python

by

💡 Problem Formulation: How does one generate XML documents in Python? Suppose you want to turn structured data, like contact information or product details, into a well-formatted XML file for sharing or integration with other systems. This article outlines various ways in Python to create an XML document from inputs like dictionaries or object attributes, aiming for an output that is a correctly structured XML file.

Method 1: Using xml.etree.ElementTree

Python’s xml.etree.ElementTree module is a standard and straightforward way to create and manipulate XML data. It provides a simple and effective solution for working with XML documents, leveraging a tree-based API that makes reading and writing XML intuitive.

Here’s an example:

import xml.etree.ElementTree as ET

root = ET.Element("Contacts")
contact = ET.SubElement(root, "Contact")
name = ET.SubElement(contact, "Name")
name.text = "John Doe"

tree = ET.ElementTree(root)
tree.write("contacts.xml")

Output:

<Contacts>
  <Contact>
    <Name>John Doe</Name>
  </Contact>
</Contacts>

This code snippet creates an XML document with a root element “Contacts” and adds a sub-element “Contact” with a child “Name” containing text “John Doe”. It then writes the XML structure to a file named “contacts.xml”.

Method 2: Using lxml library

The lxml library is a powerful, feature-rich tool for XML processing in Python. It provides support for XML path expressions, XML schema validation, and XSLT transformations, making it a great choice for more complex XML generation tasks.

Here’s an example:

from lxml import etree

root = etree.Element("Products")
product = etree.SubElement(root, "Product", attrib={"id": "X123"})
name = etree.SubElement(product, "Name")
name.text = "Widget Pro"

xml_str = etree.tostring(root, pretty_print=True, xml_declaration=True)
with open('products.xml', 'wb') as xml_file:
    xml_file.write(xml_str)

Output:

<?xml version='1.0' encoding='ASCII'?>
<Products>
  <Product id="X123">
    <Name>Widget Pro</Name>
  </Product>
</Products>

In this example, an XML structure is built using the lxml library with a root “Products” and a “Product” child with an attribute. It then writes the XML to “products.xml” with proper formatting and XML declaration.

Method 3: Using xml.dom.minidom

The xml.dom.minidom is a minimal DOM implementation in Python. It’s part of the standard library and allows for more control over XML document structure, which can be beneficial for DOM-oriented XML generation.

Here’s an example:

from xml.dom.minidom import Document

doc = Document()
root = doc.createElement("Library")
doc.appendChild(root)
book = doc.createElement("Book")
root.appendChild(book)
title = doc.createElement("Title")
title.appendChild(doc.createTextNode("1984"))
book.appendChild(title)

xml_str = root.toprettyxml(indent="  ")
with open("library.xml", "w") as xml_file:
    xml_file.write(xml_str)

Output:

<Library>
  <Book>
    <Title>1984</Title>
  </Book>
</Library>

This snippet leverages xml.dom.minidom to create a “Library” element with nested “Book” and “Title” elements, the latter containing the text “1984”. The result is written to “library.xml” with indentation for readability.

Method 4: Using yattag library

The yattag library offers a unique way of generating XML documents in Python, utilizing a fluent interface that enables writing HTML and XML in a Pythonic manner. It’s easy to install and provides a simple and flexible method for XML generation.

Here’s an example:

from yattag import Doc

doc, tag, text = Doc().tagtext()

with tag('Greetings'):
    with tag('Hello', to="World"):
        text('Hello, World!')

xml_str = doc.getvalue()
with open("greetings.xml", "w") as xml_file:
    xml_file.write(xml_str)

Output:

<Greetings>
  <Hello to="World">Hello, World!</Hello>
</Greetings>

The yattag library is used here to generate XML content with a root “Greetings” and a nested “Hello” element with an attribute and text. The resulting XML string is stored in “greetings.xml”.

Bonus One-Liner Method 5: Python’s One-Liner using dicttoxml

If you’re looking for a one-liner solution, dicttoxml converts a Python dictionary to an XML string. It is perfect for quick conversions but may lack some flexibility.

Here’s an example:

from dicttoxml import dicttoxml

data_dict = {'message': 'Hello, World!'}
xml_str = dicttoxml(data_dict)

with open("message.xml", "wb") as xml_file:
    xml_file.write(xml_str)

Output:

<?xml version="1.0" encoding="UTF-8" ?>
<root><message>Hello, World!</message></root>

This concise snippet converts a dictionary with a message into an XML string and writes it to “message.xml”.

Summary/Discussion

  • Method 1: xml.etree.ElementTree. Simple and standard way to work with XML in Python. Well-integrated into Python’s standard library. However, may not have all the advanced features provided by external libraries.
  • Method 2: lxml library. Rich in features, and supports a variety of advanced XML standards. Best suited for complex XML tasks. The downside is the additional dependency and potential overkill for simple tasks.
  • Method 3: xml.dom.minidom. Provides DOM-like manipulation capabilities. Good for users familiar with DOM concepts. However, it can be verbose and less intuitive than other methods for simple documents.
  • Method 4: yattag library. Pythonic and readable, excellent for clean and maintainable code. It’s not standard and requires an additional install, and may not be as widely adopted or supported as other methods.
  • Method 5: dicttoxml. Extremely easy to use, perfect for quick and straightforward conversions from a dictionary to XML. Can lack the flexibility and control available in other methods, and not suited for complex XML generation scenarios.