Búsqueda de sitios web

Bonita impresión XML en Python

Cuando se trata de datos XML en Python, garantizar su legibilidad y estructura puede mejorar en gran medida la comprensión y el mantenimiento del código. La impresión bonita de XML, o formatearlo con sangría y saltos de línea adecuados, es una técnica valiosa para lograr estos objetivos.

En este artículo, exploramos dos métodos diferentes para imprimir XML usando Python: xml.dom.minidom y xml.etree.ElementTree. Al comprender estos enfoques, los desarrolladores pueden presentar eficazmente datos XML de una manera organizada y visualmente atractiva, lo que facilita el análisis y la manipulación.

¿Cómo imprimir XML en Python?

A continuación se muestran los dos métodos mediante los cuales podemos realizar una impresión bonita en Python:

Método 1: usar xml.dom.minidom

A continuación se detallan los pasos que seguiremos para realizar una impresión bonita usando xml.dom.minidom:

  • Importe el módulo requerido: comenzamos importando el módulo `xml.dom.minidom`, que proporciona una implementación ligera de la API del Modelo de objetos de documento (DOM) para el análisis XML.

  • Defina la función `pretty_print_xml_minidom`: esta función toma una cadena XML como entrada y es responsable de analizar e imprimir el XML usando `xml.dom.minidom`.

  • Analizar la cadena XML: dentro de la función `pretty_print_xml_minidom`, usamos el método `xml.dom.minidom.parseString()` para analizar la cadena XML y crear un objeto DOM.

  • Imprima el XML de forma bonita: A continuación, utilizamos el método `toprettyxml()` en el objeto DOM para generar una cadena XML impresa de forma bonita. Pasamos el parámetro `sangría` con un valor de `" "` para especificar el nivel de sangría deseado (dos espacios en este caso).

  • Eliminar líneas vacías: de forma predeterminada, `toprettyxml()` agrega líneas vacías en la salida. Para eliminar estas líneas vacías, dividimos la bonita cadena XML en nuevas líneas (`\n`), eliminamos cualquier espacio en blanco inicial o final de cada línea y luego unimos las líneas no vacías nuevamente.

  • Imprime el bonito XML: Finalmente, imprimimos la bonita cadena XML resultante.

Programa 2: Uso de xml.etree.ElementTree

A continuación se detallan los pasos que seguiremos para realizar una impresión bonita usando xml.etree.ElementTree:

  • Importe el módulo requerido: comenzamos importando el módulo `xml.etree.ElementTree`, que proporciona una API rápida y eficiente para analizar y manipular XML.

  • Defina la función `indent`: esta es una función personalizada que agrega sangría de forma recursiva a los elementos XML. Se necesita un parámetro `elem` (elemento XML) y un parámetro `level` opcional para especificar el nivel de sangría actual (predeterminado en 0).

  • Sangrar el XML: Dentro de la función `indent`, agregamos sangría modificando los atributos `text` y `tail` de los elementos XML. . El atributo `text` representa el texto inmediatamente después de la etiqueta de apertura, y el atributo `tail` representa el texto inmediatamente antes de la etiqueta de cierre. Al agregar sangría a estos atributos, logramos una impresión bonita.

  • Defina la función `pretty_print_xml_elementtree`: esta función toma una cadena XML como entrada y es responsable de analizar e imprimir el XML usando `xml.etree.ElementTree`.

  • Analizar la cadena XML: dentro de la función `pretty_print_xml_elementtree`, utilizamos el método `ET.fromstring()` para analizar la cadena XML y crear un objeto ElementTree.

  • Sangrar el XML: llamamos a la función `indent()` en el elemento raíz del XML para agregar la sangría de forma recursiva a todos los elementos.

  • Convertir el elemento XML nuevamente en una cadena: utilizamos el método `ET.tostring()` para convertir el elemento XML nuevamente en una representación de cadena. Pasamos el parámetro `encoding` con un valor de `"unicode"` para garantizar la codificación adecuada de la cadena resultante.

  • Imprime el bonito XML: Finalmente, imprimimos la bonita cadena XML resultante.

Ambos programas proporcionan diferentes enfoques para lograr una impresión bonita de XML. El primer programa utiliza la API DOM proporcionada por `xml.dom.minidom` para analizar e imprimir XML, mientras que el segundo programa usa `xml.etree.ElementTree`. módulo y define una función personalizada para agregar sangría de forma recursiva a elementos XML.

A continuación se muestran ejemplos de programas que utilizan los dos métodos anteriores:

Programa 1: Uso de 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)

Producción

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

Programa 2: Uso de 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)

Producción

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

Conclusión

En conclusión, Pretty Printing XML en Python es esencial para mejorar la legibilidad y la estructura de los datos XML. Ya sea que utilicen la biblioteca xml.dom.minidom o xml.etree.ElementTree, los desarrolladores pueden formatear XML fácilmente con la sangría adecuada. Al adoptar estas técnicas, los programadores pueden mejorar la comprensión del código, simplificar la depuración y promover una mejor colaboración cuando trabajan con datos XML en proyectos de Python.

Artículos relacionados: