Análisis de XML de Python

 

En este tutorial, veremos algunos ejemplos del uso de Python para analizar XML o Lenguaje de marcado extensible. XML es como una versión más flexible de HTML. Es un lenguaje de marcado que define un conjunto de reglas para codificar documentos en un formato que es legible por humanos y legible por máquina. Hay un par de formas diferentes en que las computadoras analizan XML. La primera se conoce como API simple para XML, también conocida como SAX. La otra forma de analizar XML es mediante el DOM o el modelo de objetos de documento. Volvamos a SAX por un momento. SAX lee los datos XML de un carácter a la vez hasta el final del documento. A medida que se lee el XML, el analizador emite eventos relacionados con el contenido XML. Usando Python, podemos manejar estos eventos a medida que ocurren.

---

Eventos SAX

Cuando el analizador encuentra XML como vemos a continuación, genera un evento para cuando está comenzando, y luego, cuando el analizador alcanza este paréntesis angular de cierre de la etiqueta de apertura, enviará un evento de etiqueta de inicio con el nombre de la etiqueta y una colección. de los atributos y sus valores. Cuando el analizador alcanza el corchete de ángulo de apertura de la etiqueta de cierre, enviará un evento de etiqueta final y cuando alcance el corchete de cierre de la etiqueta de cierre, también enviará un evento para eso.

A medida que se generan estos eventos, podemos usar Python para responder y operar con los datos. Cuando se utiliza SAX, no se puede acceder al contenido del XML en orden aleatorio. Recuerde, SAX funciona moviéndose a través del archivo XML carácter por carácter hasta que llega al final del documento. No puede "rebobinar" ni hacer una copia de seguridad durante este proceso. Además, SAX no puede cambiar los datos XML durante el procesamiento. Por esta razón, SAX es bueno cuando se usa XML como archivo de configuración.

---

API SAX

Para usar la API SAX en Python, usamos el módulo xml.sax . Así que vamos a importar ese módulo para ejecutar algún código de prueba. Una vez importados, tendremos acceso a una función xml.sax.parse () que puede trabajar con un archivo o un objeto de flujo. Otra función que podemos usar es la función xml.sax.parseString () que se puede usar si ya tiene el XML en una variable de cadena. Además de estas funciones, hay una clase base denominada ContentHandler que se puede utilizar para el procesamiento de contenido personalizado. La clase ContentHandler tiene funciones para manejar el inicio y el final del documento, el inicio y el final de las etiquetas y el manejo de datos de texto. Puede crear su propia clase que anule estas funciones para manejar cada tipo de contenido.

Ejemplo XML de Python SAX

A continuación, tenemos algunos datos XML de muestra. Se almacena en un archivo de nombres xmldata.xml.

<? xml version = "1.0" encoding = "UTF-8"?>
<blogposts title = "Colección de publicaciones de blog" date = "A date" author = "Algún tipo">

   <post type = "resumen">
      <title> Analizar XML con SAX </title>
   </post>

   <post type = "detalle">
      <title> Descripción general </title>
      <entrada>
         Analizar XML es genial
      </entry>
      <entrada />
      <entrada>
         Diviértete con el análisis de XML
      </entry>
   </post>
</blogposts>

Los datos XML en los que estamos trabajando representan un elemento de publicación de blog ficticio. Hay una etiqueta raíz de publicaciones de blog y tiene algunos atributos y, dentro de las publicaciones de blog, hay algunas publicaciones y cada publicación tiene algunas entradas. El código extrae información de este XML a medida que el analizador SAX lo analiza. Hay funciones que indicarán que estamos comenzando a procesar el documento y que estamos terminando de procesar. Para imprimir el nombre de las publicaciones de blog, se utiliza la función startElement. También hay métodos de endElement, characters, startDocument y endDocument. Para ejecutar el programa, lo colocamos dentro de la función main () de Python. Se asigna una nueva instancia de CustomContentHandler a la variable del controlador. Luego, simplemente usamos xml.sax.parse () para leer los datos e imprimir algunos resultados.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

import xml.sax     # define a Custom ContentHandler class that extends ContenHandler class CustomContentHandler(xml.sax.ContentHandler):     def __init__(self):         self.postCount = 0         self.entryCount = 0         self.isInTitle = False       # Handle startElement     def startElement(self, tagName, attrs):         if tagName == 'blogposts':             print('Blogposts title: ' + attrs['title'])         elif tagName == 'post':             self.postCount += 1         elif tagName == 'entry':             self.entryCount += 1         elif tagName == 'title':             self.isInTitle = True       # Handle endElement     def endElement(self, tagName):         if tagName == 'title':             self.isInTitle = False       # Handle text data     def characters(self, chars):         if self.isInTitle:             print('Title: ' + chars)       # Handle startDocument     def startDocument(self):         print('About to start!')       # Handle endDocument     def endDocument(self):         print('Finishing up!')     def main():     # create a new content handler for the SAX parser     handler = CustomContentHandler()       # call the parse method on an XML file     xml.sax.parse('xmldata.xml', handler)       # when we're done, print out some interesting results     print(f'There were {handler.postCount} post elements')     print(f'There were {handler.entryCount} entry elements')     if __name__ == '__main__':     main()

¡A punto de empezar!
Título de las publicaciones de blog: Colección de publicaciones de blog
Título: Analizar XML con SAX
Título: Descripción general
¡Terminando!
Había 2 elementos de publicación
Había 3 elementos de entrada

Proceso terminado con código de salida 0

---

API DOM XML

Otra forma en que se puede manipular el contenido XML es mediante la API del modelo de objetos de documento o DOM. Una de las grandes diferencias entre DOM API y SAX API es que DOM le permite acceder a cualquier parte del archivo XML al azar. Esto no es posible con SAX ya que lee un carácter a la vez de principio a fin. Con DOM, también puede modificar el contenido del archivo XML. Cuando se usa DOM para analizar el código XML, el XML se lee en la memoria en su totalidad y se representa como una estructura de árbol. A continuación, puede utilizar varias API para trabajar en el árbol del documento resultante. La biblioteca estándar de Python proporciona una implementación de la API DOM en el módulo xml.dom.minidom . Se pretende que sea una implementación más pequeña que la API DOM completa. A continuación se presentan algunos de los puntos clave y métodos que debe conocer.

• Accede a cualquier parte de la estructura XML de forma aleatoria
• Modificar contenido XML
• Representa XML como una estructura de árbol jerárquica
• xml.dom.minidom es una implementación ligera
• domtree = xml.com.minidom.parseString (str)
• elem.getElementById (id)
• elem.getElementsByTagName (nombre de etiqueta)
• elem.getAttribute (nombreAtributo)
• elem.setAttribute (nombreAtributo, val)
• newElem = document.createElement (nombre de etiqueta)
• newElem = document.createTextNode (strOfText)
• elem.appendChild (newElem)

Aquí hay un ejemplo del uso de xml.dom.minidom para operar en el mismo archivo xmldata.xml que usamos en el ejemplo de SAX. Observe que este método proporciona un poco más de flexibilidad e incluso podemos agregar datos al archivo en la memoria. Muchos de nosotros estamos bastante familiarizados con DOM ya que es muy común en el desarrollo web, por lo que trabajar con XML en Python usando DOM es bastante fácil de entender.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import xml.dom.minidom     def main():     domtree = xml.dom.minidom.parse('xmldata.xml')     rootnode = domtree.documentElement       # display some information about the content     print(f'The root element is {rootnode.nodeName}')     print(f'The Title is: {rootnode.getAttribute("title")}')     entries = domtree.getElementsByTagName('entry')     print(f'There are {entries.length} entry tags')       # create a new entry tag in memory     newItem = domtree.createElement('entry')       # add some text to the entry     newItem.appendChild(domtree.createTextNode('Magic Entry!'))       # now add the entry to the first post     firstPost = domtree.getElementsByTagName('post')[0]     firstPost.appendChild(newItem)       # Now count the entry tags again     entries = domtree.getElementsByTagName('entry')     print('Now there are {0} entry tags'.format(entries.length))       # Print out the domtree as xml     print(domtree.toxml())     if __name__ == '__main__':     main()

El elemento raíz son las publicaciones de blog
El título es: Colección de publicaciones de blog
Hay 3 etiquetas de entrada
Ahora hay 4 etiquetas de entrada

<? xml version = "1.0"?> <blogposts title = "Colección de publicaciones de blog" date = "A date" author = "Some dude">

   <post type = "resumen">
      <title> Analizar XML con SAX </title>
   <entry> ¡Entrada mágica! </entry> </post>

   <post type = "detalle">
      <title> Descripción general </title>
      <entrada>
         Analizar XML es genial
      </entry>
      <entrada />
      <entrada>
         Diviértete con el análisis de XML
      </entry>
   </post>
</blogposts>

Proceso terminado con código de salida 0

---

API XML ElementTree

La API DOM es amplia y ofrece una API multiplataforma y en varios idiomas para trabajar con datos XML. La API ElementTree adopta un enfoque diferente al enfocarse en ser una forma más simple de trabajar con XML. Con la API ElementTree, los elementos se tratan como si fueran listas. Esto significa que si tiene un elemento XML que contiene otros elementos, es posible iterar sobre esos elementos secundarios usando una iteración estándar como un bucle for. La API ElementTree trata los atributos como diccionarios. Entonces, si tiene una referencia a un elemento, puede acceder a su propiedad attrib, que es un diccionario de todos los nombres y valores de los atributos. ElementTree facilita la búsqueda de contenido dentro de XML. Ofrece funciones que pueden utilizar la sintaxis XPath para buscar datos específicos en XML.

En el siguiente ejemplo, usamos la API ElementTree para probar estos conceptos. Una vez más, usamos el mismo archivo de datos XML que hemos estado usando para todo el tutorial. Podemos ver cómo construir una estructura de documento y encontrar el elemento raíz del árbol. Podemos acceder a un atributo, iterar sobre etiquetas, contar la cantidad de elementos, agregar nuevos datos, etc.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

from lxml import etree     def main():     postCount = 0     entryCount = 0       # build a doc structure using the ElementTree API     doc = etree.parse('xmldata.xml').getroot()     print(doc.tag)       # Access the value of an attribute     print(doc.attrib['title'])       # Iterate over tags     for elem in doc.findall('post'):         print(elem.tag)       # Count the number of posts     postCount = len(doc.findall('post'))     entryCount = len(doc.findall('.//entry'))       print(f'There are {postCount} post elements')     print(f'There are {entryCount} entry elements')       # Create a new post     newPost = etree.SubElement(doc, 'post')     newPost.text = 'This is a new post'       # Count the number of posts     postCount = len(doc.findall('post'))     entryCount = len(doc.findall('.//entry'))       print(f'There are now {postCount} post elements')     print(f'There are now {entryCount} entry elements')     if __name__ == '__main__':     main()

publicaciones de blog
Colección de publicaciones de blog
enviar
enviar
Hay 2 elementos de publicación
Hay 3 elementos de entrada
Ahora hay 3 elementos de publicación
Ahora hay 3 elementos de entrada

Proceso terminado con código de salida 0

Resumen de análisis de XML de Python

El problema de leer, escribir y manipular datos XML en Python se resuelve utilizando cualquiera de las bibliotecas mencionadas en este tutorial. Echamos un vistazo a la API SAX para XML, la API DOM para XML y, por último, la API ElementTree para XML. Cada uno tiene sus pros y contras, y algunos de los enlaces anteriores ofrecerán más consejos y trucos para trabajar con XML en Python.