5 Effective Ways to Convert Python Dictionaries to XML

by

💡 Problem Formulation: Converting a Python dictionary to XML is a frequent requirement in software development when there is a need to share data across different systems that may not support JSON, which is Python-friendly. For instance, a Python dictionary {'animal': 'dog', 'legs': 4} might need to be converted into a readable XML format like:

<animal>
  <type>dog</type>
  <legs>4</legs>
</animal>

Such functionality ensures interoperability between disparate systems and paves the way for seamless data exchange.

Method 1: Using xml.etree.ElementTree

The xml.etree.ElementTree module is part of Python’s standard library, which provides functionality for parsing and creating XML data. The Element and SubElement functions help to generate XML elements representing keys and values from the dictionary.

Here’s an example:

import xml.etree.ElementTree as ET

def dict_to_xml(tag, d):
    elem = ET.Element(tag)
    for key, val in d.items():
        child = ET.SubElement(elem, key)
        child.text = str(val)
    return ET.tostring(elem, encoding='unicode')

my_dict = {'animal': 'dog', 'legs': 4}
print(dict_to_xml('animal', my_dict))

The output of this code snippet:

<animal><animal>dog</animal><legs>4</legs></animal>

This code defines a function dict_to_xml() that takes in a dictionary and a root tag name, then iterates through the dictionary, creating XML elements for each key-value pair. The result is a unicode string of the XML representation.

Method 2: Using dicttoxml Library

The dicttoxml library is a third-party Python package that can be used to convert a dictionary to XML format straightforwardly. It handles various data types, including lists and nested dictionaries.

Here’s an example:

from dicttoxml import dicttoxml

my_dict = {'animal': 'dog', 'legs': 4}
xml = dicttoxml(my_dict, custom_root='animal', attr_type=False)

print(xml.decode())

The output of this code snippet:

<animal><animal>dog</animal><legs>4</legs></animal>

This code uses the dicttoxml() function from the dicttoxml library to convert the dictionary into an XML byte string. Setting attr_type=False avoids adding data type attributes to each element. The resulting XML byte string is decoded for human-readable output.

Method 3: Using lxml Library

The lxml library is a powerful Python library for working with XML and HTML. It provides safe and convenient access through the lxml.etree module, a highly compatible with the standard library’s xml.etree.ElementTree.

Here’s an example:

from lxml import etree

def dict_to_xml_str(dictionary):
    root = etree.Element('animal')
    for key, value in dictionary.items():
        child = etree.SubElement(root, key)
        child.text = str(value)
    return etree.tostring(root, pretty_print=True).decode()

my_dict = {'animal': 'dog', 'legs': 4}
print(dict_to_xml_str(my_dict))

The output of this code snippet:

<animal>
  <animal>dog</animal>
  <legs>4</legs>
</animal>

This snippet defines a function dict_to_xml_str() that constructs an XML structure with the lxml library. Each key-value pair in the dictionary adds as a subelement to a root element. Finally, it generates a pretty printed string representation of the XML.

Method 4: Using xml.dom.minidom

The xml.dom.minidom module provides a minimal implementation of the Document Object Model (DOM) interface, which can also be used for creating XML documents.

Here’s an example:

from xml.dom.minidom import Document

def dict_to_xml(input_dict, root_tag):
    doc = Document()
    root = doc.createElement(root_tag)
    doc.appendChild(root)
    for k, v in input_dict.items():
        node = doc.createElement(k)
        node.appendChild(doc.createTextNode(str(v)))
        root.appendChild(node)
    return doc.toprettyxml(indent="  ")

my_dict = {'animal': 'dog', 'legs': 4}
print(dict_to_xml(my_dict, 'animal'))

The output of this code snippet:

<?xml version="1.0" ?>
<animal>
  <animal>dog</animal>
  <legs>4</legs>
</animal>

In this example, we define a function dict_to_xml() that first creates an XML document and a root element. It then iterates through the dictionary, creating elements and appending them as children to the root element. The toprettyxml() method generates a formatted XML string.

Bonus One-Liner Method 5: Using a Generator Expression

If the dictionary is flat (doesn’t contain nested structures), a simple one-liner can create an XML string using a generator expression and string manipulation.

Here’s an example:

my_dict = {'animal': 'dog', 'legs': 4}
xml_str = '<animal>' + ''.join(f'<{k}>{v}</{k}>' for k, v in my_dict.items()) + '</animal>'

print(xml_str)

The output of this code snippet:

<animal><animal>dog</animal><legs>4</legs></animal>

This one-liner concatenates a series of XML elements generated by a generator expression that iterates through each item in the dictionary. The items are wrapped in start and end tags that correspond to their keys.

Summary/Discussion

  • Method 1: xml.etree.ElementTree. Native Python module. Handles basic cases well. Not suitable for complex XML structures with attributes or namespace considerations.
  • Method 2: dicttoxml Library. Robust handling of various data types. External dependency. May be overkill for simple use cases.
  • Method 3: lxml Library. Powerful and flexible. Can handle complex XML tasks. External dependency and potentially slower than native solutions.
  • Method 4: xml.dom.minidom. Simple DOM-based approach. May be less intuitive to those unfamiliar with the DOM. Good for more document-oriented XML creation.
  • Bonus Method 5: Generator Expression. Quick and dirty. Only suitable for flat dictionaries. Lacks flexibility and features for working with XML.