XML- und RSS-Feeds in Python parsen

Parse xml rss feeds python cover

Daten liegen in unterschiedlichen Formaten vor, von einfachen CSV-Tabellen und JSON-Objekten bis hin zu aussagekräftigeren, hierarchischen XML-Dokumenten. XML mag etwas altmodisch wirken, ist aber nach wie vor überall zu finden: in RSS-Feeds, APIs und Softwarekonfigurationen.

Bevor Sie XML-Daten verwenden können, müssen Sie sie parsen. Anders gesagt: Sie bringen Ihrem Programm bei, den enthaltenen Inhalt zu lesen. Mit Python-Bibliotheken wie ElementTree, minidom und lxml ist das Parsen von XML ein klarer und intuitiver Prozess.

Unabhängig davon, auf welches Datenformat Sie stoßen: Der Umgang damit, insbesondere mit XML, ist eine unverzichtbare Fähigkeit für alle Entwickler. In diesem Leitfaden erfahren Sie Schritt für Schritt, wie Sie XML lesen, darin navigieren und Daten daraus extrahieren.

Die Grundlagen von XML

XML steht für eXtensible Markup Language und ist ein universelles Format zum Speichern und Übertragen von Daten. Dank seiner Struktur lässt es sich von Menschen leicht lesen und bleibt zugleich mit Maschinen kompatibel. Die Sprache wurde mit Blick auf Einfachheit, Anpassungsfähigkeit und breite Nutzbarkeit im Internet entwickelt.

XML lässt sich am besten als Baum beschreiben. Ähnlich wie ein echter Baum mit Ästen und Blättern besitzt es ein Wurzelelement und verschachtelte Kindelemente. Dieses Modell veranschaulicht, wie XML Daten hierarchisch anordnet. Python bietet verschiedene Möglichkeiten zur Verarbeitung von XML-Daten, wobei das Modul ElementTree zu den beliebtesten gehört. Das ElementTree-Modul umfasst zwei zentrale Klassen: ElementTree für das gesamte Dokument und Element für einen einzelnen Knoten. 

XML parsen: die wichtigsten Techniken für Entwickler

In Python ist die parse() function in der Regel der erste Schritt bei der Verarbeitung von XML-Dateien. Sie verarbeitet ein XML-Dokument und wandelt es in eine Baumstruktur um, durch die Ihr Programm navigieren kann. Diese Funktion bildet die Grundlage für verschiedene Parsing-Methoden, unabhängig davon, ob Sie ElementTree, lxml oder andere Bibliotheken verwenden.

Um die Parsing-Methoden zu verstehen, sollten Sie zunächst die Elemente einer XML-Datei kennen:

  • Namensraum – hilft, Namenskonflikte zu vermeiden, indem die Namen von Elementen und Attributen qualifiziert werden.
  • Wurzelelement – der Hauptcontainer, der alle anderen Elemente umfasst.
  • Attribute – Schlüssel-Wert-Paare, die zusätzliche Informationen über Elemente liefern.
  • Kindelemente – verschachtelte Elemente, die Daten hierarchisch organisieren.
  • Textinhalt – die eigentlichen Informationen, die in Elementen enthalten sind.

Diese Elemente bilden ein strukturiertes Format, mit dem Programme komplexe Daten speichern und austauschen können. Nachdem wir die Struktur verstanden haben, betrachten wir die wichtigsten XML-Parsing-Techniken in Python: 

1. ElementTree-Modul  

Eine integrierte Python-Bibliothek mit einer leicht nutzbaren API zum Erkunden von XML-Bäumen. Sie eignet sich hervorragend für die meisten Aufgaben, da sie Benutzerfreundlichkeit und Leistung ausbalanciert.  

2. lxml  

Eine Drittanbieterbibliothek mit Unterstützung für XPath, XSLT und Validierung. Sie ist schneller und funktionsreicher als ElementTree und eignet sich hervorragend für komplexe XML-Verarbeitung.  

3. DOM (Document Object Model)    

Dabei wird das vollständige XML-Dokument als Baumstruktur in den Speicher geladen. Zwar ist es leicht zu navigieren und zu verändern, bei größeren Dateien kann es jedoch viel Speicher beanspruchen. 

4. SAX (Simple API for XML)  

Ein ereignisgesteuerter Parser, der XML sequenziell verarbeitet. Er geht sparsam mit Speicher um und verarbeitet große Dateien schnell, ist bei komplexen Vorgängen aber weniger intuitiv.  

5. Untangle  

Wandelt XML-Daten für einen einfachen Zugriff in Python-Objekte um. Es eignet sich perfekt für schnelles Parsen mit minimalem Code, ist für komplexe XML-Strukturen jedoch weniger anpassungsfähig.  

Für dieses Tutorial benötigen Sie…

  • Python and Python requests 

Falls Python 3.x noch nicht auf Ihrem Computer installiert ist, können Sie es unter https://www.python.org/. herunterladen. Öffnen Sie ein Terminal und installieren Sie Requests mit pip:

pip install requests oder  pip3 install requests

  • Visual Studio Code (VS Code)

Zum Ausführen aller erforderlichen Befehle können Sie das Terminal in Visual Studio Code (VS Code) verwenden. Laden Sie es einfach von der offiziellen Website herunter und folgen Sie den Installationsanweisungen für Ihr Betriebssystem.

  • RSS Feed

Ein RSS-Feed ist ein spezielles XML-Dateiformat, das Nachrichten oder Aktualisierungen einer Website automatisch bereitstellt. Einfach gesagt ist er eine Art Liste der neuesten Beiträge, die so strukturiert ist, dass Programme sie lesen können.

Auf unserer Website gibt es beispielsweise einen Bereich mit Tutorials. Statt die Seite täglich darauf zu prüfen, ob ein neues Tutorial veröffentlicht wurde, stellt die Website einen RSS-Feed bereit, also eine XML-Datei mit Informationen zu allen aktuellen Beiträgen. Für dieses Tutorial verwenden wir den DataImpulse RSS feed . Sehen wir uns nun die benötigten Bibliotheken und den folgenden Code an.

ElementTree

Sehen wir uns an, wie Sie mit dem integrierten Python-Modul ElementTree XML-Daten aus einem RSS-Feed parsen. 

Der erste Schritt besteht darin, xml.etree.ElementTreezu importieren. Der Ablauf ist einfach: Wir senden eine GET-Anfrage an die RSS-Feed-URL, und der Server antwortet mit XML-Daten. Das Attribut .content der Antwort liefert die Rohdaten als Bytes, die ElementTree parsen kann. Mit ET.fromstring()wandeln wir diesen XML-Text in eine Baumstruktur um und erhalten das Wurzelelement. Darin sind die meisten Inhalte unter den Elementen <channel> → <item> organisiert.

Die find() -Methode gibt das erste passende Element zurück, während findall() alle Kindelemente mit einem bestimmten Tag zurückgibt. Hier ist items eine Liste aller Elemente, die jeweils ein Tutorial oder einen Artikel darstellen.

Codebeispiel: 


import xml.etree.ElementTree as ET
import requests

# URL of the RSS feed (from DataImpulse site)
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download the XML data
response = requests.get(FEED_URL)
xml_data = response.content

# Parse the XML
root = ET.fromstring(xml_data)

# In RSS feeds, items are inside 
channel = root.find("channel")
items = channel.findall("item")

# Print titles and links of the items
for item in items:
   title = item.findtext("title")
   link = item.findtext("link")
   print(f"Title: {title}")
   print(f"Link: {link}\n")

Zum Schluss extrahieren und geben wir mit findtext()den Titel und Link jedes Eintrags aus; die Methode ruft den Textinhalt direkt ab. Wenn Sie das Skript ausführen, erhalten Sie eine übersichtlich ausgegebene Liste aller Tutorialtitel und ihrer URLs. 

lxml  

Lxml ist eine externe Bibliothek, die den Funktionsumfang von ElementTree erweitert und XPath unterstützt, eine Abfragesprache zum Navigieren in XML-Dokumenten. In diesem Beispiel verwenden wir lxml.etree zum Parsen eines RSS-Feeds und zum Extrahieren von Beitragstiteln.

Zunächst rufen wir den RSS-Feed mit requests.get()ab, genau wie zuvor. Der Antwortinhalt wird an etree.fromstring()übergeben, wodurch das XML geparst und das Wurzelelement zurückgegeben wird. Mit lxml können wir XPath-Ausdrücke nutzen, um Elemente zu finden, da sie die Navigation schneller und flexibler machen als die Standardmethoden von ElementTree.


import requests
from lxml import etree

# URL of the RSS feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download the XML data
response = requests.get(FEED_URL)
xml_data = response.content

# Parse XML
root = etree.fromstring(xml_data)
items = root.xpath("//channel/item")

# Show list of titles with numbers
print("Available blog posts:\n")
for item in items:
   title = item.findtext("title")
   print(title)

Zum Schluss durchlaufen wir die <item> -Elemente, extrahieren mit findtext(“title”)den Titel jedes Beitrags und geben ihn aus.

Minidom  

In diesem Beispiel verwenden wir Minidom, kurz für Minimal DOM Implementation. Es ist Teil der Python-Standardbibliothek und lädt das gesamte XML-Dokument als Document Object Model (DOM) in den Speicher. 

Wir rufen minidom.parseString() auf, um das XML zu parsen und ein DOM-Objekt (doc)zu erstellen. Unter den bekannten DOM-Methoden verwenden wir zwei. Die erste ist getElementsByTagName(“tag”,) , die alle Elemente mit einem bestimmten Tag-Namen findet. Die nächste ist .firstChild.nodeValue , die den Textinhalt eines Knotens abruft.

Zum Schluss verwenden wir toprettyxml(). Sie dient dazu, das erste item-Element in einem formatierten XML-Layout auszugeben.  

So parsen Sie mit Minidom Daten aus einem RSS-Feed:


import requests
from xml.dom import minidom

# URL of the RSS feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download XML data
response = requests.get(FEED_URL)
xml_data = response.content

# Parse XML with minidom
doc = minidom.parseString(xml_data)

# Get all  elements
items = doc.getElementsByTagName("item")

print(f"Total articles found in feed: {len(items)}\n")

# Show titles with links
for i, item in enumerate(items, start=1):
   title = item.getElementsByTagName("title")[0].firstChild.nodeValue
   link = item.getElementsByTagName("link")[0].firstChild.nodeValue
   print(f"{i}. {title}")
   print(f"   Link: {link}\n")

# Show raw XML of the first  (just for demo)
print("First  as raw XML:\n")
print(items[0].toprettyxml())

SAX  

SAX liest XML sequenziell, Element für Element. Für jeden XML-Teil löst es bestimmte Ereignisse aus:

  • startElement(name, attrs) → wenn ein Tag beginnt
  • characters(content) → wenn Text zwischen Tags gelesen wird
  • endElement(name) → wenn ein Tag endet

Speichern Sie den Code in einer Datei und führen Sie ihn aus: 


import requests
import xml.sax

# Custom handler for SAX parsing
class RSSHandler(xml.sax.ContentHandler):
   def __init__(self):
       super().__init__()
       self.current_tag = ""
       self.in_item = False
       self.title = ""
       self.link = ""
       self.counter = 0

   def startElement(self, name, attrs):
       if name == "item":
           self.in_item = True
           self.title = ""
           self.link = ""
       self.current_tag = name

   def characters(self, content):
       if self.in_item:
           if self.current_tag == "title":
               self.title += content
           elif self.current_tag == "link":
               self.link += content

   def endElement(self, name):
       if name == "item":
           self.counter += 1
           print(f"{self.counter}. {self.title.strip()}")
           print(f"   Link: {self.link.strip()}\n")
           self.in_item = False
       self.current_tag = ""

# Download the XML feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"
response = requests.get(FEED_URL)
xml_data = response.content

# Parse XML with SAX
print("Parsing RSS feed with SAX...\n")
handler = RSSHandler()
xml.sax.parseString(xml_data, handler)

print(f"Total items parsed: {handler.counter}")

Der Vorteil dieser Methode ist ihre Speichereffizienz, da sie nicht das gesamte Dokument speichert. 

Untangle

Diese Methode gilt als einfachere Art, XML zu verarbeiten. Die Bibliothek Untangle wandelt XML-Dokumente in Python-Objekte um. Dadurch sind weder das manuelle Durchlaufen von Elementen noch die Ereignisbehandlung nötig. 

Wenn Sie XML mit untangle.parse(), parsen, liest die Funktion die XML-Datei automatisch, wandelt jeden XML-Tag in ein Python-Objekt um und speichert Tag-Daten in .cdata -Attributen, sofern es sich um Textinhalt handelt. Statt mit Knoten oder Ereignissen zu arbeiten, navigieren Sie einfach wie bei einem normalen Python-Objekt durch die XML-Struktur. 

Hier ist der Code: 


import requests
import untangle
from io import BytesIO

# RSS feed from DataImpulse
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download XML
resp = requests.get(FEED_URL)
resp.raise_for_status()
xml_bytes = resp.content

# Parse XML with untangle (use BytesIO for bytes input)
doc = untangle.parse(BytesIO(xml_bytes))

# Get all  elements
items = doc.rss.channel.item

print("Articles from DataImpulse RSS:\n")

# Print articles
for i, it in enumerate(items, start=1):
   title = it.title.cdata if hasattr(it, "title") else ""
   link = it.link.cdata if hasattr(it, "link") else ""
   desc = it.description.cdata if hasattr(it, "description") else ""
  
   print(f"{i}. {title}")
   print(f"   Link: {link}")
   if desc:
       print(f"   Description: {desc}")
   print()

Einige zusätzliche Empfehlungen

  • Beim Parsen auf Fehler prüfen

Manchmal sind Feeds nicht verfügbar oder enthalten unerwartete Tags. Verwenden Sie in solchen Fällen try/except beim Herunterladen oder Parsen von XML.

  • Verwenden Sie .content für XML-Downloads

Die .content -Attribut liefert Rohdaten als Bytes und verhindert so Kodierungsprobleme, die das .text -Attribut verursachen könnte.

  • Prüfen, ob Elemente vorhanden sind 

Nicht jede XML-Datei hat dieselbe Struktur. Verwenden Sie Bedingungen wie if item.find(‘title’) is not None bevor Sie auf Tags zugreifen.

  • Bei großen Dateien auf den Ressourcenverbrauch achten

Verwenden Sie für sehr große XML-Dokumente SAX, das Daten sequenziell liest, ohne alles in den Speicher zu laden.

Das Abrufen von XML von externen Websites kann problematisch sein. Proxies sorgen für reibungslosen Zugriff an verschiedenen Standorten und schützen die Privatsphäre.

Wichtige Punkte

  • Beim Parsen von XML werden XML-Dateien gelesen und Daten strukturiert sowie nutzbar extrahiert.
  • ElementTree bietet einen baumbasierten Ansatz zum Navigieren und Extrahieren von XML-Elementen.
  • lxml ist eine Bibliothek, die XPath-Abfragen für schnelleres XML-Parsing unterstützt.
  • Minidom lädt das gesamte XML als DOM-Baum, sodass Sie wie bei einem strukturierten Objekt auf Knoten und Text zugreifen können.
  • SAX ist ideal für große XML-Dateien, weil es XML Schritt für Schritt verarbeitet, ohne alles im Speicher zu halten.
  • Untangle wandelt XML in Python-Objekte um, damit Sie einfach auf Tags und ihre Inhalte zugreifen können.

Ähnliche Artikel 

Proxies in Python requests integrieren

eBay mit Python und Proxies scrapen

DataImpulse Proxies in Java konfigurieren

Amazon-Produktdaten mit Python scrapen

Einen eigenen Proxy-Rotator mit Python erstellen

Sicherheitsprüfungen mit Python und Selenium bewältigen

Share article: