Python bietet verschiedene Möglichkeiten, XML zu analysieren ...

Ich verstehe die Grundlagen des Parsens mit SAX . Es fungiert als Stream-Parser mit einer ereignisgesteuerten API.

Ich verstehe auch den DOM- Parser. Es liest das XML in den Speicher und konvertiert es in Objekte, auf die mit Python zugegriffen werden kann.

Im Allgemeinen war es einfach, zwischen beiden zu wählen, je nachdem, was Sie tun mussten, Speicherbeschränkungen, Leistung usw.

(Hoffentlich bin ich soweit richtig.)

Seit Python 2.5 haben wir auch ElementTree . Wie ist das im Vergleich zu DOM und SAX? Welchem ​​ist es ähnlicher? Warum ist es besser als die vorherigen Parser?

ElementTree ist viel einfacher zu verwenden, da es einen XML-Baum (im Grunde genommen) als Listenstruktur darstellt und Attribute als Wörterbücher dargestellt werden.

ElementTree benötigt für XML-Bäume viel weniger Speicher als DOM (und ist daher schneller), und der Parsing-Overhead über iterparseist mit SAX vergleichbar. Gibt außerdem iterparseTeilstrukturen zurück, und Sie können die Speichernutzung während des Parsens konstant halten, indem Sie die Strukturen verwerfen, sobald Sie sie verarbeiten.

ElementTree verfügt wie in Python 2.5 nur über einen kleinen Funktionsumfang im Vergleich zu vollständigen XML-Bibliotheken, reicht jedoch für viele Anwendungen aus. Wenn Sie einen validierenden Parser oder eine vollständige XPath-Unterstützung benötigen, ist lxml der richtige Weg. Früher war es ziemlich instabil, aber seit 2.1 hatte ich keine Probleme mehr damit.

ElementTree weicht von DOM ab, wo Knoten Zugriff auf ihre Eltern und Geschwister haben. Der Umgang mit tatsächlichen Dokumenten anstelle von Datenspeichern ist ebenfalls etwas umständlich, da Textknoten nicht als tatsächliche Knoten behandelt werden. Im XML-Snippet

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

Die Zeichenfolge testwird das sogenannte tailvon-Element sein b.

Im Allgemeinen empfehle ich ElementTree als Standard für die gesamte XML-Verarbeitung mit Python und DOM oder SAX als Lösung für bestimmte Probleme.

Minimale DOM-Implementierung:

Link .

Python bietet eine vollständige W3C-Standardimplementierung von XML DOM ( xml.dom ) und eine minimale xml.dom.minidom . Letzteres ist einfacher und kleiner als die vollständige Implementierung. Aus einer "Parsing-Perspektive" hat es jedoch alle Vor- und Nachteile des Standard-DOM - dh es lädt alles in den Speicher.

Betrachten einer grundlegenden XML-Datei:

<?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>

Ein möglicher Python-Parser mit Minidom ist:

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

Beachten Sie, dass xml.parsers.expat eine Python-Schnittstelle zum nicht validierenden Expat-XML-Parser ist (docs.python.org/2/library/pyexpat.html).

Das xml.dom- Paket enthält auch die Ausnahmeklasse DOMException , wird jedoch nicht in minidom unterstützt !

Die ElementTree XML-API:

Link .

ElementTree ist viel einfacher zu verwenden und benötigt weniger Speicher als XML DOM. Darüber hinaus ist eine C-Implementierung verfügbar ( xml.etree.cElementTree ).

Ein möglicher Python-Parser mit ElementTree ist:

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

ElementTree hat mehr pythonische API. Es befindet sich jetzt auch in der Standardbibliothek, sodass durch die Verwendung Abhängigkeiten reduziert werden.

Eigentlich bevorzuge ich lxml, da es eine API wie ElementTree hat, aber auch nette zusätzliche Funktionen hat und eine gute Leistung erbringt.

ElementTrees parse () ist wie DOM, während iterparse () wie SAX ist. Meiner Meinung nach ist ElementTree besser als DOM und SAX, da es eine API bietet, mit der man einfacher arbeiten kann.