Pretty Printing XML in Python

Introduction:

In this tutorial we are learning about how to Pretty Printing XML in Python. When processing XML data in Python, making it readable and structured can improve the understandability and manageability of your code. Printing the XML nicely or formatting it with appropriate indentation and line breaks is an important process to achieve these goals. Basically, the XML stands for Extensible Markup Language. It is used to encode information that humans and machines can understand. Data stored in XML format is easy to understand and manipulate. There are three important things to remember when working with XML which are simplicity, versatility, and usability.

In this tutorial, we will look at two ways to print XML using Python: xml.dom.minidom and xml.etree.ElementTree. By understanding this process, developers can effectively present XML data in an organized and visual way, making it easier to analyze and manage.

How do you print XML in Python?

There are two methods to do pretty printing XML in Python, which are given below -

Method 1: Using the xml.dom.minidom

Here, we are given some steps to do pretty printing XML using the xml.dom.minidom in Python. The steps are as follows -

Import all the required modules: Firstly, we need to import the 'xml.dom.minidom' module, which makes deep use of the Document Object Model (DOM) API for XML parsing.
Defining the 'pretty_print_xml_minidom' function:The function accepts an XML string as input and is responsible for parsing and printing the pretty XML using the "xml.dom .minidom" module.
Parsing the string in XML: In the 'pretty_print_xml_minidom' function, we use the 'xml.dom.minidom.parseString()' method to parse the string in XML and then create a DOM object.
Print the pretty XML: Next, we use the "toprettyxml()" method of the DOM object to create a pretty XML string. We pass the "indent" parameter with the value `" "` to specify the desired indentation level (in this case, two spaces).
Remove blank lines: By default, the 'toprettyxml()' function adds blank or empty lines to the output. To remove these blank lines, we nicely split the XML string with newlines (`\n`), remove the leading or white spaces of each line, and then the non-empty lines join back together.
Pretty print the XML: Lastly, we print the result of the Pretty XML string in Python.

Program Code:

Here, we give the program code to print the pretty XML string using the xml.dom.minidom in Python. It is parsing the DOM API. The code is given below -

# Here, we import the "xml.dom.minidom" module
import xml.dom.minidom

# Here, we define the function print_pretty_xml with parameters
def print_pretty_xml(s):
   # Here we parsing the XML string
   dom = xml.dom.minidom.parseString(s)

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

   # The empty lines are removed here
   pretty_xml = "\n".join(line for line in pretty_xml.split("\n") if line.strip())

   # Here, we print the pretty XML string
   print(pretty_xml)

# The string is initialized here
s = '''
<jtp>
  <element attribute="value">
   <Name>Priyanka Adhikary</Name>
  </element>
</jtp>
'''

print_pretty_xml(s)

Output:

Now, we compile and run the above program and find the pretty printing XML string in Python. The pretty printing XML output is given below -

<?xml version="1.0" ?>
<jtp>
  <element attribute="value">
    <Name>Priyanka Adhikary</Name>
  </element>
</jtp>

Method 2: Using the xml.etree.ElementTree

Here, we have given some steps to do pretty printing XML using the xml.etree.ElementTree in Python. The steps are -

The required modules imported: Firstly, we import the 'xml.etree.ElementTree' module, which provides a fast and efficient API for parsing and processing XML.
Definition of the 'Indent' function: This is a special function that recursively adds indents to XML elements. It must have an "elem" parameter (XML element) and an optional "level" parameter that indicates the current indentation level (default is 0).
Indent XML: In the "indent" function, we add indentation by changing the "text" and "tail" attributes of the XML element. The "text" character represents the text immediately after the open label, and the "tail" character represents the text immediately before the closed label. By adding indentations to these products, we achieve better printing.
Defining the 'pretty_print_xml_elementtree' function: This function takes an XML string as input and is responsible for parsing the XML and printing it nicely using the 'xml.etree.ElementTree' module in Python.
Parsing the XML string: In the 'pretty_print_xml_elementtree' function, we use the `ET.fromstring()` method to parse the XML string and create the ElementTree object.
Indent XML:We call the 'indent()' function of the XML element to recursively indent all elements.
Convert the XML content back to a string: We use the ET.tostring() method to convert the XML content back to a string representation. To ensure the correct encoding of the resulting string, we pass the "encoding" parameter with the value "unicode".
Printing the pretty XML:Finally, we print the pretty XML string in Python.

Program Code:

Here we give the program code to print the pretty XML string using the xml.etree.ElementTree module in Python. It defines a custom function that recursively indents XML elements. The code is given below -

# Here, we import the "xml.etree.ElementTree" module in the form of ET
import xml.etree.ElementTree as ET

# Here, we define the function ind with parameter e and level
def ind(e, level=0):
   # Here, we add all the indentation
   ind_size = "  "
   i = "\n" + level * ind_size
   if len(e):
      if not e.text or not e.text.strip():
         e.text = i + ind_size
      if not e.tail or not e.tail.strip():
         e.tail = i
      for e in e:
         ind(e, level + 1)
      if not e.tail or not e.tail.strip():
         e.tail = i
   else:
      if level and (not e.tail or not e.tail.strip()):
         e.tail = i

def pretty_print_xml_elementtree(s_xml):
   # The XML string is parsing here
   r = ET.fromstring(s_xml)

   # Here, we give the indentation of the XML string
   ind(r)

   # Here, we convert the XML element back to a string
   pretty_xml = ET.tostring(r, encoding="unicode")

   # Here we printing the pretty XML string
   print(pretty_xml)

# The string is initialized here
s_xml = '''
<jtp>
  <element attribute="value">
   <Name>Priyanka Adhikary</Name>
  </element>
</jtp>
'''

pretty_print_xml_elementtree(s_xml)

Output:

Now, we compile and run the above program and find the pretty printing XML string in Python. The pretty printing XML output is given below -

<jtp>
  <element attribute="value">
    <Name>Priyanka Adhikary</Name>
  </element>
</jtp>

Conclusion:

In this tutorial, we are learning about Printing Pretty XML in Python. As a result, printing pretty XML in Python is crucial to improving the readability and structure of your XML files. Developers can easily format XML with quality, whether using the xml.dom.minidom or xml.etree.ElementTree modules. By using these techniques, programmers can improve code understanding, simplify debugging, and support better collaboration when working with XML files in Python projects.

Next TopicConvert the case of elements in a list of strings in python

← prev next →