XML mit Python parsen

Erfahren Sie, wie Sie XML in Python mit Bibliotheken wie ElementTree, lxml und SAX parsen, um Ihre Datenverarbeitungsprojekte zu verbessern.

• Schlüsselkonzepte einer XML-Datei
• Verschiedene Möglichkeiten, XML in Python zu parsen
• ElementTree
• lxml
• minidom
• SAX-Parser

Schlüsselkonzepte einer XML-Datei

Bevor Sie sich damit beschäftigen, wie Sie XML in Python parsen, ist es wichtig, zunächst zu verstehen, was eine XML Schema Definition (XSD) ist und welche grundlegenden Elemente eine XML-Datei ausmachen. Dieses Grundlagenwissen hilft Ihnen dabei, die richtige Python-Bibliothek für Ihre Parsing-Anforderungen auszuwählen.

XSD ist eine Schema-Spezifikation, die die Struktur, den Inhalt und die in einem XML-Dokument zulässigen Datentypen definiert. Es dient als Satz von Validierungsregeln und stellt sicher, dass XML-Dateien einem konsistenten Format folgen.

Eine XML-Datei enthält typischerweise Elemente wie Namespace, root, attributes, elements und text content, die zusammen strukturierte Daten darstellen.

• Namespace identifiziert Elemente und Attribute in XML-Dokumenten eindeutig. Er hilft, Namenskollisionen zu vermeiden, und unterstützt die Interoperabilität zwischen verschiedenen XML-Datensätzen.
• root ist das Element der obersten Ebene eines XML-Dokuments. Es dient als Einstiegspunkt in die XML-Struktur und umfasst alle anderen Elemente.
• attributes liefern zusätzlichen Kontext zu einem Element. Sie werden im Start-Tag eines Elements definiert und bestehen aus Name-Wert-Paaren.
• elements sind die Kerneinheiten einer XML-Datei und repräsentieren die eigentlichen Daten oder Struktur-Tags. Elemente können ineinander verschachtelt werden, um eine Hierarchie aufzubauen.
• text content bezieht sich auf die tatsächlichen Textdaten zwischen dem Start- und End-Tag eines Elements. Dies kann Klartext, numerische Werte oder andere Zeichen umfassen.

Zum Beispiel folgt die Bright Data sitemap dieser XML-Struktur:

• urlset dient als root-Element.
• <urlset xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"> ist die Namespace-Deklaration für das urlset-Element. Dies zeigt an, dass die Schema-Regeln für urlset und alle verschachtelten Elemente gelten.
• url ist ein direktes Kindelement des root-Elements.
• loc ist ein Kindelement innerhalb des url-Elements.

Da Sie nun ein klareres Bild von XSD und der XML-Struktur haben, ist es an der Zeit, dieses Wissen anzuwenden, indem Sie eine XML-Datei mit einigen hilfreichen Python-Bibliotheken parsen.

Verschiedene Möglichkeiten, XML in Python zu parsen

Verwenden wir die Bright Data sitemap. In den folgenden Beispielen werden die Inhalte der Bright Data sitemap mit der Python-Bibliothek requests abgerufen.

Die Python-Bibliothek requests ist nicht Bestandteil der Standardbibliothek, daher müssen Sie sie vor dem Fortfahren installieren. Sie können dies mit dem folgenden Befehl tun:

pip install requests

ElementTree

Die ElementTree XML API bietet eine unkomplizierte und benutzerfreundliche Möglichkeit, XML-Daten in Python zu parsen und zu erzeugen. Da sie Teil der Python-Standardbibliothek ist, ist keine zusätzliche Installation erforderlich.

Sie können zum Beispiel die Methode findall() verwenden, um alle url-Elemente aus dem Root abzurufen und den Textinhalt jedes loc-Elements wie folgt auszugeben:

import xml.etree.ElementTree as ET
import requests

url = 'https://brightdata.de/post-sitemap.xml'

response = requests.get(url)
if response.status_code == 200:
   
    root = ET.fromstring(response.content)

    for url_element in root.findall('.//{http://www.sitemaps.org/schemas/sitemap/0.9}url'):
        loc_element = url_element.find('{http://www.sitemaps.org/schemas/sitemap/0.9}loc')
        if loc_element is not None:
            print(loc_element.text)
else:
    print("Failed to retrieve XML file from the URL.")

Alle URLs in der sitemap werden in der Ausgabe ausgegeben:

https://brightdata.de/case-studies/powerdrop-case-study
https://brightdata.de/case-studies/addressing-brand-protection-from-every-angle
https://brightdata.de/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.de/case-studies/the-seo-transformation
https://brightdata.de/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.de/case-studies/highly-targeted-influencer-marketing
https://brightdata.de/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.de/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.de/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.de/case-studies/data-intensive-analytical-solutions
https://brightdata.de/case-studies/canopy-advantage-solutions
https://brightdata.de/case-studies/seamless-digital-automations

ElementTree ist ein einfacher und intuitiver XML-Parser in Python, ideal für kleine Skripte wie das Lesen von RSS-Feeds. Allerdings fehlt ihm eine robuste Schema-Validierung und er ist möglicherweise nicht für komplexes oder groß angelegtes XML-Parsing geeignet — Bibliotheken wie lxml sind für solche Fälle besser.

lxml

lxml ist eine schnelle, einfach zu verwendende und funktionsreiche API zum Parsen von XML-Dateien in Python. Sie können lxml installieren mit pip:

pip install lxml

Nach der Installation können Sie lxml verwenden, um XML-Dateien mit verschiedenen API-Methoden zu parsen, wie z. B. find(), findall(), findtext(), get(), und get_element_by_id().

Sie können zum Beispiel die Methode findall() verwenden, um über die url-Elemente zu iterieren, deren loc-Elemente zu finden (die Kindelemente des url-Elements sind) und anschließend den Location-Text mit folgendem Code auszugeben:

from lxml import etree
import requests

url = "https://brightdata.de/post-sitemap.xml"

response = requests.get(url)
if response.status_code == 200:

    root = etree.fromstring(response.content)
    

    for url in root.findall(".//{http://www.sitemaps.org/schemas/sitemap/0.9}url"):
        loc = url.find("{http://www.sitemaps.org/schemas/sitemap/0.9}loc").text.strip()
        print(loc)
else:
    print("Failed to retrieve XML file from the URL.")

Die Ausgabe zeigt alle in der sitemap gefundenen URLs an:

https://brightdata.de/case-studies/powerdrop-case-study
https://brightdata.de/case-studies/addressing-brand-protection-from-every-angle
https://brightdata.de/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.de/case-studies/the-seo-transformation
https://brightdata.de/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.de/case-studies/highly-targeted-influencer-marketing
https://brightdata.de/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.de/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.de/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.de/case-studies/data-intensive-analytical-solutions
https://brightdata.de/case-studies/canopy-advantage-solutions
https://brightdata.de/case-studies/seamless-digital-automations

Bis zu diesem Punkt haben Sie gesehen, wie Sie Elemente lokalisieren und deren Werte anzeigen. Als Nächstes sehen wir uns an, wie Sie eine XML-Datei vor dem Parsen gegen ihr Schema validieren. Dieser Schritt bestätigt, dass die Datei der in der XSD definierten Struktur folgt.

So sieht die XSD der sitemap aus:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.sitemaps.org/schemas/sitemap/0.9"
           xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
           elementFormDefault="qualified"
           xmlns:xhtml="http://www.w3.org/1999/xhtml">

  
  <xs:element name="urlset">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="url" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element name="url">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="loc" type="xs:anyURI"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

</xs:schema>

Um die sitemap für die Schema-Validierung zu verwenden, stellen Sie sicher, dass Sie sie manuell kopieren und eine Datei mit dem Namen schema.xsd erstellen.

Validieren Sie nun die XML-Datei mit dieser XSD:

from lxml import etree

import requests

url = "https://brightdata.de/post-sitemap.xml"

response = requests.get(url)

if response.status_code == 200:

    root = etree.fromstring(response.content)

    try:
        print("Schema Validation:")
        schema_doc = etree.parse("schema.xsd")  
        schema = etree.XMLSchema(schema_doc)  
        schema.assertValid(root)  
        print("XML is valid according to the schema.")
    except etree.DocumentInvalid as e:
        print("XML validation error:", e)

In diesem Schritt parsen Sie die XSD-Datei mit der Methode etree.parse(), erstellen anschließend ein XML Schema aus dem geparsten Inhalt und validieren schließlich den XML-Root mit assertValid() gegen dieses Schema. Wenn die XML-Datei die Validierung besteht, sehen Sie eine Nachricht wie XML is valid according to the schema; andernfalls wird eine DocumentInvalid-Exception ausgelöst.

Ihre Ausgabe sollte wie folgt aussehen:

 Schema Validation:
    XML is valid according to the schema.

Lesen wir nun eine XML-Datei, die die Methode xpath verwendet, um die Elemente anhand ihres Pfads zu finden.

Um die Elemente mit der Methode xpath() zu lesen, verwenden Sie den folgenden Code:

from lxml import etree

import requests

url = "https://brightdata.de/post-sitemap.xml"
response = requests.get(url)

if response.status_code == 200:
   
    root = etree.fromstring(response.content)
    
    print("XPath Support:")
    root = etree.fromstring(response.content)

    namespaces = {"ns": "http://www.sitemaps.org/schemas/sitemap/0.9"}
    for url in root.xpath(".//ns:url/ns:loc", namespaces=namespaces):
        print(url.text.strip())

In diesem Snippet registrieren Sie das Präfix ns und verknüpfen es mit der Namespace-URI http://www.sitemaps.org/schemas/sitemap/0.9. Der XPath-Ausdruck verwendet dann dieses Präfix, um Elemente mit Namespace gezielt anzusprechen. Konkret wählt .//ns:url/ns:loc alle loc-Elemente aus, die Kindelemente von url-Elementen innerhalb dieses Namespace sind.

Die Ausgabe wird wie folgt aussehen:

XPath Support:

https://brightdata.de/case-studies/powerdrop-case-study
https://brightdata.de/case-studies/addressing-brand-protection-from-every-angle
https://brightdata.de/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.de/case-studies/the-seo-transformation
https://brightdata.de/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.de/case-studies/highly-targeted-influencer-marketing
https://brightdata.de/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.de/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.de/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.de/case-studies/data-intensive-analytical-solutions
https://brightdata.de/case-studies/canopy-advantage-solutions
https://brightdata.de/case-studies/seamless-digital-automations

Die Methoden find() und findall() sind schneller als xpath(), da xpath() alle Ergebnisse in den Speicher lädt. Verwenden Sie find(), es sei denn, Sie benötigen komplexere Abfragen.

lxml ist eine leistungsstarke Bibliothek zum Parsen von XML und HTML und unterstützt fortgeschrittene Funktionen wie XPath, Schema-Validierung und XSLT. Sie ist ideal für hochperformante oder komplexe Aufgaben, erfordert jedoch eine separate Installation.

Wenn Sie mit großen oder komplexen XML-Daten arbeiten — wie z. B. Finanz-Feeds — ist lxml eine starke Wahl für effizientes Abfragen, Validieren und Transformieren.

minidom

minidom ist eine einfache und leichtgewichtige XML-Parsing-Bibliothek, die in der Python-Standardbibliothek enthalten ist. Obwohl sie nicht so funktionsreich oder effizient wie lxml ist, bietet sie eine einfache Möglichkeit, XML-Daten zu parsen und zu manipulieren.

Sie können verschiedene DOM-Methoden verwenden, um auf Elemente zuzugreifen. Zum Beispiel ermöglicht die getElementsByTagName() method, Elemente anhand ihres Tag-Namens abzurufen.

Hier ist ein Beispiel für die Verwendung der Bibliothek minidom, um eine XML-Datei zu parsen und Elemente anhand ihrer Tag-Namen abzurufen:

import requests
import xml.dom.minidom

url = "https://brightdata.de/post-sitemap.xml"

response = requests.get(url)
if response.status_code == 200:
    dom = xml.dom.minidom.parseString(response.content)
    
    urlset = dom.getElementsByTagName("urlset")[0]
    for url in urlset.getElementsByTagName("url"):
        loc = url.getElementsByTagName("loc")[0].firstChild.nodeValue.strip()
        print(loc)
else:
    print("Failed to retrieve XML file from the URL.")

Ihre Ausgabe würde wie folgt aussehen:

https://brightdata.de/case-studies/powerdrop-case-study
https://brightdata.de/case-studies/addressing-brand-protection-from-every-angle
https://brightdata.de/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.de/case-studies/the-seo-transformation
https://brightdata.de/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.de/case-studies/highly-targeted-influencer-marketing
https://brightdata.de/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.de/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.de/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.de/case-studies/data-intensive-analytical-solutions
https://brightdata.de/case-studies/canopy-advantage-solutions
https://brightdata.de/case-studies/seamless-digital-automations

minidom repräsentiert XML-Daten als DOM-Baum, wodurch sie leicht zu navigieren und zu manipulieren sind. Es ist ideal für grundlegende Aufgaben wie das Lesen, Ändern oder Erstellen einfacher XML-Strukturen.

Wenn Ihr Programm Einstellungen aus einer XML-Datei lesen muss, ermöglicht minidom einen einfachen Zugriff auf bestimmte Elemente, z. B. das Finden von Kindknoten oder Attributen. So können Sie beispielsweise schnell einen font-size-Knoten abrufen und dessen Wert in Ihrer Anwendung verwenden.

SAX-Parser

Der SAX parser ist ein ereignisgesteuerter XML-Parser, der Dokumente sequenziell verarbeitet und Ereignisse wie Start-Tags, End-Tags und Textinhalte ausgibt. Im Gegensatz zu DOM-Parsern lädt SAX nicht das gesamte Dokument in den Speicher, was ihn ideal für große XML-Dateien macht, bei denen Speichereffizienz wichtig ist.

Um SAX zu verwenden, definieren Sie Ereignis-Handler für bestimmte XML-Ereignisse, wie z. B. startElement und endElement, die Sie anpassen können, um die Struktur und den Inhalt des Dokuments zu verarbeiten.

Hier ist ein Beispiel für die Verwendung des SAX-Parsers zur Verarbeitung einer XML-Datei, wobei Ereignis-Handler definiert werden, um URL-Informationen aus einer sitemap zu extrahieren:

import requests
import xml.sax.handler
from io import BytesIO

class MyContentHandler(xml.sax.handler.ContentHandler):
    def __init__(self):
        self.in_url = False
        self.in_loc = False
        self.url = ""

    def startElement(self, name, attrs):
        if name == "url":
            self.in_url = True
        elif name == "loc" and self.in_url:
            self.in_loc = True

    def characters(self, content):
        if self.in_loc:
            self.url += content

    def endElement(self, name):
        if name == "url":
            print(self.url.strip())
            self.url = ""
            self.in_url = False
        elif name == "loc":
            self.in_loc = False

url = "https://brightdata.de/post-sitemap.xml"

response = requests.get(url)
if response.status_code == 200:

    xml_content = BytesIO(response.content)
    
    content_handler = MyContentHandler()
    parser = xml.sax.make_parser()
    parser.setContentHandler(content_handler)
    parser.parse(xml_content)
else:
    print("Failed to retrieve XML file from the URL.")

Ihre Ausgabe würde wie folgt aussehen:

https://brightdata.de/case-studies/powerdrop-case-study
https://brightdata.de/case-studies/addressing-brand-protection-from-every-angle
https://brightdata.de/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.de/case-studies/the-seo-transformation
https://brightdata.de/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.de/case-studies/highly-targeted-influencer-marketing
https://brightdata.de/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.de/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.de/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.de/case-studies/data-intensive-analytical-solutions
https://brightdata.de/case-studies/canopy-advantage-solutions
https://brightdata.de/case-studies/seamless-digital-automations

Im Gegensatz zu anderen Parsern, die die gesamte Datei in den Speicher laden, verarbeitet SAX Dateien inkrementell, spart Speicher und verbessert die Leistung. Allerdings erfordert es mehr Code, um jedes Datensegment zu verarbeiten, und erlaubt es nicht, später zur Analyse auf Teile der Daten zurückzugreifen.

SAX ist ideal, um große XML-Dateien (z. B. Log-Dateien) effizient zu scannen und bestimmte Informationen (z. B. Fehlermeldungen) zu extrahieren. Wenn Ihre Analyse jedoch Beziehungen zwischen verschiedenen Datensegmenten untersuchen muss, ist SAX möglicherweise nicht die beste Wahl.

Fazit

Python bietet vielseitige Bibliotheken, um das XML-Parsing zu vereinfachen. Wenn Sie jedoch die Bibliothek requests verwenden, um online auf Dateien zuzugreifen, können Quota- und Throttling-Probleme auftreten. Bright Data bietet zuverlässige Proxy-Lösungen, um diese Einschränkungen zu umgehen.

Wenn Sie das Scraping und Parsing lieber überspringen möchten, sehen Sie sich unseren dataset marketplace kostenlos an!