Pretty printing XML in Python

When working with XML data in Python, ensuring its readability and structure can greatly enhance the understanding and maintainability of your code. Pretty-printing XML, that is, formatting it with appropriate indentation and newlines, is a valuable technique for achieving these goals.

In this article, we'll explore two different ways to pretty-print XML using Python: xml.dom.minidom and xml.etree.ElementTree. By understanding these methods, developers can effectively present XML data in an organized and visually appealing way, making it easier to analyze and manipulate.

How to pretty print XML in Python?

Here are two ways we can perform pretty printing in Python -

Method 1: Use xml.dom.minidom

Here are the steps we will take to perform pretty printing using xml.dom.minidom -

• Import the required modules: We first import the "xml.dom.minidom" module, which provides a lightweight implementation of the Document Object Model (DOM) API for XML parsing.

• Define the `pretty_print_xml_minidom` function: This function accepts an XML string as input and is responsible for parsing and beautifying the XML for printing using `xml.dom.minidom`.

• Parse XML string: Inside the `pretty_print_xml_minidom` function, we use the `xml.dom.minidom.parseString()` method to parse the XML string and create a DOM object.

• Pretty-printing XML: Next, we use the "toprettyxml()" method on the DOM object to generate a pretty-printing XML string. We pass the "indent" parameter with the value """ to specify the desired indentation level (two spaces in this case).

• Remove blank lines: By default, `toprettyxml()` adds blank lines to the output. To remove these empty lines, we split the pretty XML string with newlines (`\n`), remove any leading or trailing whitespace in each line, and then concatenate the non-empty lines back together.

• Print pretty XML: Finally, we print the generated pretty XML string.

Procedure 2: Using xml.etree.ElementTree

Here are the steps we will follow to perform pretty printing using xml.etree.ElementTree -

• Import the required modules: We first import the `xml.etree.ElementTree` module, which provides a fast and efficient API for parsing and manipulating XML.

• Definition`indent` Function: This is a custom function used to recursively add indents to XML elements. It accepts an `elem` parameter (XML element) and an optional `level` parameter to specify the current indentation level (default is 0).

• Indent XML: In the `indent` function, we add indent > XML by modifying `text` and `tail` The element's properties. The `text` attribute represents the text immediately after the opening tag, and the `tail` attribute represents the text immediately before the closing tag. By adding indentation to these properties, we achieve pretty printing.

• Definition `pretty_print_xml_elementtree` Function: This function takes an XML string as input and is responsible for parsing and pretty-printing the XML using `xml.etree.ElementTree`.

• Parsing XML string: Inside the `pretty_print_xml_elementtree` function, we use the `ET.fromstring()` method to parse the XML string and create an ElementTree object.

• Indent XML: We call the `indent()` function on the root element of the XML to add indentation to all elements recursively.

• Convert XML elements back to strings: We use the `ET.tostring()` method to convert XML elements back to string representation. We pass the `encoding` parameter with the value `"unicode"` to ensure the correct encoding of the resulting string.

• Print pretty XML: Finally, we print the generated pretty XML string.

These two programs provide different methods to achieve pretty printing of XML. The first program utilizes the DOM API provided by `xml.dom.minidom` to parse and pretty print XML, while the second program uses the `xml.etree.ElementTree` module, And defined a custom function to add indentation to XML elements recursively.

The following are program examples using the above two methods -

Option 1: Use xml.dom.minidom

import xml.dom.minidom

def pretty_print_xml_minidom(xml_string):
   # Parse the XML string
   dom = xml.dom.minidom.parseString(xml_string)

   # Pretty print the XML
   pretty_xml = dom.toprettyxml(indent="  ")

   # Remove empty lines
   pretty_xml = "\n".join(line for line in pretty_xml.split("\n") if line.strip())

   # Print the pretty XML
   print(pretty_xml)

# Example usage
xml_string = '''
<root>
  <element attribute="value">
   <subelement>Text</subelement>
  </element>
</root>
'''

pretty_print_xml_minidom(xml_string)

Output

<?xml version="1.0" ?>
<root>
  <element attribute="value">
   <subelement>Text</subelement>
  </element>
</root>

Procedure 2: Using xml.etree.ElementTree

import xml.etree.ElementTree as ET

def indent(elem, level=0):
   # Add indentation
   indent_size = "  "
   i = "\n" + level * indent_size
   if len(elem):
      if not elem.text or not elem.text.strip():
         elem.text = i + indent_size
      if not elem.tail or not elem.tail.strip():
         elem.tail = i
      for elem in elem:
         indent(elem, level + 1)
      if not elem.tail or not elem.tail.strip():
         elem.tail = i
   else:
      if level and (not elem.tail or not elem.tail.strip()):
         elem.tail = i

def pretty_print_xml_elementtree(xml_string):
   # Parse the XML string
   root = ET.fromstring(xml_string)

   # Indent the XML
   indent(root)

   # Convert the XML element back to a string
   pretty_xml = ET.tostring(root, encoding="unicode")

   # Print the pretty XML
   print(pretty_xml)

# Example usage
xml_string = '''
<root>
  <element attribute="value">
   <subelement>Text</subelement>
  </element>
</root>
'''

pretty_print_xml_elementtree(xml_string)

Output

<root>
  <element attribute="value">
   <subelement>Text</subelement>
  </element>
</root>

in conclusion

In summary, pretty-printing XML in Python is crucial to improving the readability and structure of your XML data. Whether using the xml.dom.minidom or xml.etree.ElementTree libraries, developers can easily format XML with proper indentation. By employing these techniques, programmers can enhance code understanding, simplify debugging, and promote better collaboration when working with XML data in Python projects.

The above is the detailed content of Pretty printing XML in Python. For more information, please follow other related articles on the PHP Chinese website!