python - example - Análisis XML-ElementTree vs SAX y DOM

xml python 3

Question

Python tiene varias formas de analizar XML ...

Entiendo los conceptos básicos de análisis con SAX . Funciona como un analizador de flujo, con una API controlada por eventos.

También entiendo el analizador DOM . Lee el XML en memoria y lo convierte en objetos a los que se puede acceder con Python.

En términos generales, fue fácil elegir entre los 2 dependiendo de lo que necesita hacer, las limitaciones de memoria, el rendimiento, etc.

(espero que esté correcto hasta ahora).

Desde Python 2.5, también tenemos ElementTree . ¿Cómo se compara esto con DOM y SAX? ¿A qué se parece más? ¿Por qué es mejor que los analizadores sintácticos anteriores?

Answer 1

Implementación mínima de DOM:

Link .

Python proporciona una implementación estándar W3C completa de DOM XML ( xml.dom ) y uno mínimo, xml.dom.minidom . Este último es más simple y más pequeño que la implementación completa. Sin embargo, desde una "perspectiva de análisis", tiene todos los pros y contras del DOM estándar, es decir, carga todo en la memoria.

Considerando un archivo XML básico:

<?xml version="1.0"?>
<catalog>
    <book isdn="xxx-1">
      <author>A1</author>
      <title>T1</title>
    </book>
    <book isdn="xxx-2">
      <author>A2</author>
      <title>T2</title>
    </book>
</catalog>

Un posible analizador de Python usando minidom es:

import os
from xml.dom import minidom
from xml.parsers.expat import ExpatError

#-------- Select the XML file: --------#
#Current file name and directory:
curpath = os.path.dirname( os.path.realpath(__file__) )
filename = os.path.join(curpath, "sample.xml")
#print "Filename: %s" % (filename)

#-------- Parse the XML file: --------#
try:
    #Parse the given XML file:
    xmldoc = minidom.parse(filepath)
except ExpatError as e:
    print "[XML] Error (line %d): %d" % (e.lineno, e.code)
    print "[XML] Offset: %d" % (e.offset)
    raise e
except IOError as e:
    print "[IO] I/O Error %d: %s" % (e.errno, e.strerror)
    raise e
else:
    catalog = xmldoc.documentElement
    books = catalog.getElementsByTagName("book")

    for book in books:
        print book.getAttribute(''isdn'')
        print book.getElementsByTagName(''author'')[0].firstChild.data
        print book.getElementsByTagName(''title'')[0].firstChild.data

Tenga en cuenta que xml.parsers.expat es una interfaz de Python para el analizador XML no validado de Expat (docs.python.org/2/library/pyexpat.html).

El paquete xml.dom también proporciona la clase de excepción DOMException , ¡pero no se incluye en minidom !

La API ElementTree XML:

Link .

ElementTree es mucho más fácil de usar y requiere menos memoria que XML DOM. Además, está disponible una implementación de C ( xml.etree.cElementTree ).

Un posible analizador de Python que utiliza ElementTree es:

import os
from xml.etree import cElementTree  # C implementation of xml.etree.ElementTree
from xml.parsers.expat import ExpatError  # XML formatting errors

#-------- Select the XML file: --------#
#Current file name and directory:
curpath = os.path.dirname( os.path.realpath(__file__) )
filename = os.path.join(curpath, "sample.xml")
#print "Filename: %s" % (filename)

#-------- Parse the XML file: --------#
try:
    #Parse the given XML file:
    tree = cElementTree.parse(filename)
except ExpatError as e:
    print "[XML] Error (line %d): %d" % (e.lineno, e.code)
    print "[XML] Offset: %d" % (e.offset)
    raise e
except IOError as e:
    print "[XML] I/O Error %d: %s" % (e.errno, e.strerror)
    raise e
else:
    catalogue = tree.getroot()

    for book in catalogue:
        print book.attrib.get("isdn")
        print book.find(''author'').text
        print book.find(''title'').text

Answer 2

El análisis sintáctico de ElementTree () es como DOM, mientras que iterparse () es como SAX. En mi opinión, ElementTree es mejor que DOM y SAX, ya que proporciona API más fácil de trabajar.

Answer 3

ElementTree es mucho más fácil de usar, ya que representa un árbol XML (básicamente) como una estructura de listas, y los atributos se representan como diccionarios.

ElementTree necesita mucha menos memoria para árboles XML que DOM (y, por lo tanto, es más rápido), y la iterparse análisis a través de iterparse es comparable a SAX. Además, iterparse devuelve estructuras parciales, y puede mantener el uso de memoria constante durante el análisis descartando las estructuras tan pronto como las procese.

ElementTree, como en Python 2.5, tiene solo un pequeño conjunto de características en comparación con las bibliotecas XML completas, pero es suficiente para muchas aplicaciones. Si necesita un analizador de validación o soporte completo de XPath, lxml es el camino a seguir. Durante mucho tiempo, solía ser bastante inestable, pero no he tenido ningún problema con él desde 2.1.

ElementTree se desvía de DOM, donde los nodos tienen acceso a sus padres y hermanos. Manejar documentos reales en lugar de almacenar datos también es un poco engorroso, porque los nodos de texto no se tratan como nodos reales. En el fragmento de XML

<a>This is <b>a</b> test</a>

La test cuerda será la llamada tail del elemento b .

En general, recomiendo ElementTree como predeterminado para todo el procesamiento XML con Python, y DOM o SAX como soluciones para problemas específicos.

Answer 4

ElementTree tiene más API pythonic. También está en la biblioteca estándar ahora, por lo que usarlo reduce las dependencias.

Realmente prefiero lxml ya que tiene API como ElementTree, pero también tiene buenas características adicionales y funciona bien.