XPath Web Scraping: Ein praktischer Leitfaden mit Python-Beispielen

Kurzfassung: XPath ist eine Abfragesprache, mit der man HTML-/XML-Bäume anhand von Pfaden, Attributen oder Textinhalten durchsuchen kann. Dieser Leitfaden behandelt die XPath-Syntax, Achsen und Funktionen und zeigt anschließend funktionierende Python-Scraper mit lxml und Selenium. Außerdem erhältst du ein übersichtliches Spickzettel sowie einen Abschnitt zur Fehlerbehebung für die häufigsten XPath-Fehler.

XPath (XML Path Language) ist eine Abfragesprache, die mithilfe von Pfadausdrücken Knoten aus XML- und HTML-Dokumenten auswählt. Wenn Ihnen CSS-Selektoren für Ihre Scraping-Aufgaben zu eingeschränkt erscheinen, ist Web-Scraping mit XPath der logische nächste Schritt.

Während CSS-Selektoren sich im DOM nur vorwärts und nach unten bewegen, durchläuft XPath das DOM in jede Richtung: nach oben zu einem übergeordneten Element, seitwärts zu einem gleichrangigen Element oder tief in verschachtelte untergeordnete Elemente hinein. Es kann Elemente auch anhand ihres sichtbaren Textes abgleichen – eine Fähigkeit, die CSS gänzlich fehlt. Diese Funktionen machen XPath für das Web-Scraping besonders wertvoll auf komplexen oder schlecht strukturierten Seiten.

In diesem Tutorial lernen Sie die grundlegende XPath-Syntax kennen (Pfade, Prädikate, Achsen, Funktionen), erfahren, wie Sie Ausdrücke in Ihrem Browser testen, und erstellen echte Python-Scraper mit lxml und Selenium. Wir behandeln auch die häufigen Fallstricke, die XPath-Selektoren in der Produktion zum Scheitern bringen, und wie man sie vermeidet.

Was ist XPath und warum sollte man es für das Web-Scraping verwenden?

XPath behandelt ein HTML- oder XML-Dokument als Baum aus Knoten und bietet Ihnen eine kompakte Syntax, um genau auf die Knoten zu verweisen, die Sie benötigen. Stellen Sie sich das wie einen Dateipfad vor: Genauso wie /home/user/docs/file.txt man durch Verzeichnisse navigiert, /html/body/div/p durch den DOM-Baum zu einem bestimmten Absatz.

Drei Gründe, warum sich XPath für das Scraping auszeichnet:

Bidirektionale Durchquerung. XPath bewegt sich nicht nur nach unten, sondern auch zu übergeordneten oder vorgelagerten Elementen. CSS-Selektoren gehen nur vorwärts.
Textbasierte Auswahl. Sie können Elemente anhand von sichtbarem Text finden (z. B. das <a> Tag mit der Aufschrift „Next Page“), was mit CSS nicht möglich ist.
Integrierte Funktionen. contains(), starts-with()und normalize-space() ermöglichen es Ihnen, unübersichtliche Markups ohne reguläre Ausdrücke zu verarbeiten.

Das Schreiben solider XPath-Ausdrücke ist eine praktische Fähigkeit, die sich bei allem, was über einfache Seiten hinausgeht, schnell auszahlt. XPath wird von vielen Sprachen unterstützt (Python, JavaScript, C#, PHP), sodass sich die Syntaxkenntnisse unabhängig von Ihrem Tech-Stack direkt übertragen lassen.

Wie das DOM mit XPath-Ausdrücken zusammenhängt

Das Document Object Model (DOM) strukturiert jedes HTML-Element, jedes Attribut und jeden Textknoten in einem Baum, in dem jeder Knoten einen Elternknoten, Kinderknoten und Geschwisterknoten hat. Betrachten Sie diesen Markup:

<ul id="menu">
  <li class="active">Home</li>
  <li>About</li>
</ul>

Hier <ul> ist der Elternknoten. Die <li> Elemente sind seine Kinder und untereinander Geschwister. Der XPath //ul[@id='menu']/li[1] lautet: Finde jedes <ul> mit id="menu", dann nimm sein erstes <li> Kind. Jede XPath-Abfrage ist letztlich eine Reihe von Anweisungen durch diese Eltern-Kind-Geschwister-Struktur, weshalb es wichtig ist, das DOM zu verstehen, bevor man einen Selektor schreibt.

Grundlagen der XPath-Syntax

Es gibt zwei Arten von XPath-Pfaden. Absolute Pfade beginnen an der Wurzel (/html/body/div/p) und sind präzise, aber anfällig: Eine einzige strukturelle Änderung macht sie unbrauchbar. Relative Pfade beginnen mit // und durchsuchen den gesamten Baum, was sie für XPath-Web-Scraping-Workflows weitaus widerstandsfähiger macht.

Operator	Bedeutung	Beispiel
`/`	Direktes Kind	`/html/body/div`
`//`	Beliebiger Nachkomme	`//div[@class='price']`
`..`	Übergeordneter Knoten	`//span/..`
`@`	Zugriff auf Attribute	`//a[@href]`

Auswahl von Knoten mit Prädikaten

Prädikate sind in Klammern eingeschlossene Filter, die eine Knotenmenge einschränken:

//ul/li[1]                  ← first <li>
//ul/li[last()]              ← last <li>
//input[@type='email']       ← by attribute
//a[text()='Next Page']      ← by exact text
//span[contains(text(),'$')] ← by partial text

Prädikate machen XPath-Ausdrücke zu einem wirklich leistungsstarken Werkzeug für die Datenextraktion. Ohne sie bräuchte man Nachbearbeitungscode, um unerwünschte Treffer aus den Ergebnissen herauszufiltern.

Achsen definieren die Richtung der Durchquerung relativ zum aktuellen Knoten und sind ein wesentlicher Grund dafür, dass XPath-Web-Scraping-Selektoren Elemente erreichen können, die CSS einfach nicht erreichen kann.

Achse	Richtung	Anwendungsfall beim Scraping
`child::`	Direkte Kinder	Wähle `<li>` Elemente innerhalb eines `<ul>`
`descendant::`	Alle verschachtelten Knoten	Alle Links innerhalb eines Containers abrufen
`parent::`	Eine Ebene höher	Von einem Preis `<span>`zu seinem Produkt gelangen `<div>`
`ancestor::`	Beliebiger Vorfahr	Von einer Zelle aus das `<table>` , zu dem es gehört
`following-sibling::`	Nächste Geschwister	Nach einem `<dt>` Bezeichnung, nimm den `<dd>` Wert
`preceding-sibling::`	Vorherige Geschwister	Suche ausgehend von einem bekannten Element rückwärts nach einer Überschrift

Praktisches Beispiel für das Scraping einer Definitionsliste:

undefined//dt[text()='Price']/following-sibling::dd[1]

Dies erfasst das erste <dd> nach dem <dt> , das „Preis“ enthält. Die following-sibling -Achse macht dies trivial, während CSS zusätzliches JavaScript oder Wrapper-Logik erfordern würde.

Leistungsstarke XPath-Funktionen für das Scraping

HTML in der Praxis ist unübersichtlich. XPath-Funktionen helfen Ihnen dabei, Selektoren zu schreiben, die dynamische Klassen, versteckte Leerzeichen und sich ändernde Attributwerte überstehen.

contains(@class, 'product')       ← matches "product-card", "product_item"
starts-with(@id, 'listing-')      ← matches "listing-001", "listing-002"
text()                             ← targets visible text content
normalize-space()='In Stock'       ← collapses whitespace before comparing
not(contains(@class, 'ad'))        ← excludes ad containers

contains() ist besonders nützlich auf Seiten, auf denen Frameworks generierte Suffixe an Klassennamen anhängen. normalize-space() löst das frustrierende Problem, bei dem ein XPath-Selektor zwar korrekt aussieht, aber fehlschlägt, weil der Text von versteckten Tabulatoren oder Zeilenumbrüchen umgeben ist. Zusammen machen diese Funktionen Ihre XPath-Ausdrücke widerstandsfähig auf echten Websites, auf denen die Konsistenz des Markups nie garantiert ist.

XPath-Spickzettel als Schnellreferenz

Setzen Sie ein Lesezeichen für diese zusammengefasste Referenz, um beim Schreiben Ihrer XPath-Web-Scraping-Selektoren schnell nachschlagen zu können.

Kategorie	Syntax	Was es tut
Pfad	`//tag`	Alle übereinstimmenden Tags an beliebiger Stelle
Pfad	`/parent/child`	Direkte untergeordnete Elemente
Pfad	`..`	Übergeordneter Knoten
Prädikat	`[n]`	N-tes Element (ab 1)
Prädikat	`[@attr='val']`	Nach Attribut filtern
Achse	`ancestor::tag`	Beliebiger Vorfahr
Achse	`following-sibling::tag`	Nächstes Geschwisterelement
Funktion	`contains()`	Teilweise Zeichenfolgenübereinstimmung
Funktion	`normalize-space()`	Leerzeichen entfernen
Funktion	`text()`	Textinhalt auswählen

Für eine ausführlichere Darstellung von Operatoren und zusammengesetzten Ausdrücken bietet unser XPath-Spickzettel eine erweiterte Referenz.

XPath in den Browser-Entwicklertools testen

Überprüfen Sie Ihre XPath-Ausdrücke im Browser, bevor Sie Code schreiben. Öffnen Sie die DevTools (F12), wechseln Sie zum Element-Panel und drücken Sie Strg+F (Cmd+F auf dem Mac). Die Suchleiste akzeptiert XPath und hebt passende Knoten in Echtzeit hervor.

Sie können auch mit der rechten Maustaste auf ein beliebiges Element klicken und „Kopieren > XPath kopieren“ wählen. Seien Sie vorsichtig: Der Browser generiert absolute Pfade wie /html/body/div[3]/section[1]/ul/li[2]/a , die bei jeder strukturellen Änderung nicht mehr funktionieren. Schreiben Sie automatisch generierte Pfade immer in relative Ausdrücke um, die an stabilen Attributen (IDs, data-* Attribute, semantische Klassennamen) anstatt an Positionsindizes.

XPath-Web-Scraping mit Python: Schritt für Schritt

Lassen Sie uns XPath mit Python in die Praxis umsetzen. Die beiden gängigsten Bibliotheken für XPath-Web-Scraping in Python sind lxml (statisches HTML) und Selenium (JavaScript-gerenderte Seiten). Im Folgenden greifen wir mit beiden auf dieselbe Website zu, damit Sie die Benutzerfreundlichkeit der APIs direkt vergleichen können.

Verwendung von XPath mit lxml

lxml ist eine schnelle, auf C basierende Bibliothek, die auf libxml2 aufbaut. Wenn die Seite kein JavaScript benötigt, ist lxml die richtige Wahl.

import requests
from lxml import html

response = requests.get("https://books.toscrape.com/")
tree = html.fromstring(response.content)
titles = tree.xpath('//article[@class="product_pod"]/h3/a/@title')
for title in titles:
    print(title)

HTML abrufen mit requests, parsen mit html.fromstring()und abfragen mit .xpath(). Das Ergebnis ist eine einfache Python-Liste. Für umfassendere Python-Scraping-Muster behandelt unser Leitfaden zum Web-Scraping mit Python die Bearbeitung von Anfragen und die Datenspeicherung ausführlich.

Verwendung von XPath mit Selenium

Wenn Seiten Inhalte über JavaScript rendern, benötigen Sie eine Browser-Engine. Selenium steuert einen Headless-Browser an und stellt XPath über find_elements. Ab Selenium 4 ist der WebDriver Berichten zufolge im Paket enthalten (überprüfen Sie dies anhand der aktuellen Selenium-Release-Notes, bevor Sie sich darauf verlassen).

from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
driver.get("https://books.toscrape.com/")
elements = driver.find_elements(By.XPATH, '//article[contains(@class,"product_pod")]/h3/a')
for el in elements:
    print(el.get_attribute("title"))
driver.quit()

Der XPath ist nahezu identisch mit der lxml-Version. Der Unterschied liegt in der API: .xpath() versus find_elements(By.XPATH, ...). Weitere Informationen zu Workflows mit Headless-Browsern finden Sie in unserem Tutorial zu Selenium und Python-Scraping, das Automatisierungsmuster erläutert. Wählen Sie lxml für statische Seiten und greifen Sie nur dann auf einen Headless-Browser zurück, wenn die Ausführung von JavaScript wirklich erforderlich ist.

XPath vs. CSS-Selektoren: Wann was verwenden

Kriterien	XPath	CSS-Selektoren
Richtung	Nach oben, unten, seitwärts	Nur vorwärts
Textübereinstimmung	Nativ (`text()`, `contains()`)	Nicht unterstützt
Lesbarkeit	Ausführlich, aber eindeutig	Prägnant
Leistung	In der Praxis ungefähr gleich	In Benchmarks etwas schneller
Lernkurve	Steiler	Einfacher

Verwenden Sie CSS, wenn Ziele allein über Klasse oder ID erreichbar sind. Verwenden Sie XPath für Scraping-Aufgaben, die eine Durchquerung der übergeordneten Elemente, Textabgleich oder Navigation auf mehreren Ebenen erfordern. Viele erfahrene Scraper kombinieren beide Methoden frei miteinander. Für einen tiefergehenden Vergleich behandelt unsere Seite „XPath vs. CSS-Selektoren“ weitere Randfälle und Auswahlstrategien.

Was die Leistung angeht, wird XPath manchmal als langsamer bezeichnet, obwohl der Unterschied in der Regel vernachlässigbar ist, wenn die Netzwerklatenz Ihre Scraping-Workload dominiert. Die Geschwindigkeit des Selektors wird in realen Projekten selten zum Engpass.

Häufige XPath-Fehler und wie man sie behebt

Instabile, automatisch generierte Pfade. Aus dem Browser kopierte XPaths verwenden absolute Indizes. Schreiben Sie diese um, um sie an stabilen Attributen wie @id oder @data-testid.

Namensraumkonflikte. Wenn XPath auf XHTML-Seiten keine Ergebnisse liefert, stören wahrscheinlich Namensraumpräfixe. Verwenden Sie local-name() , um sie zu umgehen: //*[local-name()='div'].

Nicht übereinstimmende Leerzeichen. text()='In Stock' schlägt fehl, wenn die Quelle versteckte Zeilenumbrüche oder Tabulatoren enthält. Umschließen Sie die Prüfung mit normalize-space() , um Leerzeichen zunächst zu komprimieren.

Dynamische Klassennamen. Frameworks wie React generieren gehashtete Klassennamen (z. B. card__a3xK2). Verwenden Sie contains(@class, 'card') , um nur das stabile Präfix abzugleichen.

Testen Sie Ihre XPath-Selektoren an einer kleinen Stichprobe, bevor Sie auf Tausende von Seiten skalieren. Das Debuggen eines fehlerhaften Selektors auf einer einzelnen Seite ist unkompliziert; das Debuggen nach einem großen Batch-Lauf verschwendet Zeit und Bandbreite.

Wichtige Erkenntnisse

XPath navigiert in jeder Richtung durch HTML und ist damit vielseitiger als CSS-Selektoren für komplexe Scraping-Aufgaben.
Verwenden Sie immer relative Pfade (//) gegenüber absoluten Pfaden, um Selektoren widerstandsfähig gegen DOM-Änderungen zu halten.
Verwenden Sie Funktionen wie contains(), normalize-space()und text() , um unübersichtliche Markups aus der Praxis zu verarbeiten.
Für statisches HTML ist lxml die schnellste Python-Option. Verwenden Sie Selenium nur für Seiten, die JavaScript-Rendering erfordern.
Testen Sie jeden XPath-Ausdruck zunächst in den DevTools des Browsers und schreiben Sie automatisch generierte Pfade um, um stabile Anker zu verwenden.

FAQ

Ist XPath besser als CSS-Selektoren für das Web-Scraping?

Keines von beiden ist universell besser. XPath eignet sich hervorragend, wenn Sie eine Durchquerung der übergeordneten Elemente, textbasierte Übereinstimmungen oder komplexe Filterung benötigen. CSS-Selektoren lassen sich für einfache Klassen- oder ID-Auswahlen schneller schreiben und schneiden in synthetischen Benchmarks tendenziell etwas besser ab. Die meisten Scraper in der Produktion verwenden beides und wählen je nach Aufgabe den passenden Selektor aus.

Kann XPath JavaScript-gerenderte Seiten scrapen?

XPath ist eine Abfragesprache, keine Rendering-Engine. Es arbeitet mit jedem DOM, das es erhält. Um JavaScript-gerenderte Inhalte zu scrapen, benötigen Sie zunächst ein Tool, das das JavaScript der Seite ausführt (wie einen Headless-Browser), und wenden dann XPath-Ausdrücke auf das resultierende DOM an. Statische Parser sehen nur die rohe Serverantwort vor jeglichem clientseitigen Rendering.

Welche Python-Bibliothek eignet sich am besten für das Web-Scraping mit XPath?

Für statische Seiten ist lxml der Standard: schnell, gut dokumentiert und durch bewährte C-Bibliotheken unterstützt. Für dynamische Seiten bietet Selenium XPath-Unterstützung über seine find_elements API. Scrapy bietet über seine Selector-Klasse ebenfalls native XPath-Unterstützung und ist damit eine solide Wahl für vollständige Crawling-Pipelines.

Warum schlägt der aus Chrome DevTools kopierte XPath im Code manchmal fehl?

Chrome generiert absolute Pfade mit Positionsindizes basierend auf dem Live-DOM, das Elemente enthalten kann, die von JavaScript oder Browser-Erweiterungen eingefügt wurden. Wenn Ihr Parser den rohen HTML-Code verarbeitet (bevor JS ausgeführt wird), weicht die Struktur ab, sodass Positionsindizes auf die falschen Elemente verweisen. Schreiben Sie den Ausdruck um und verwenden Sie stabile Attribute anstelle von Positionen.

Fazit

XPath-Web-Scraping bietet Ihnen eine Präzision, mit der einfachere Selektor-Methoden nicht mithalten können. Mit der hier behandelten Syntax, den Achsen, Funktionen und Python-Mustern sollten Sie in der Lage sein, alles zu bewältigen – von der Auswahl grundlegender Attribute bis hin zur Navigation durch tief verschachtelte, inkonsistent strukturierte Seiten.

Der Schlüssel zur Verbesserung ist Übung: Beginnen Sie mit einem einfachen Ziel, testen Sie Ausdrücke in DevTools und steigern Sie die Komplexität schrittweise. Halten Sie Selektoren relativ, nutzen Sie Funktionen für Markup-Variabilität und validieren Sie immer an einem kleinen Stapel, bevor Sie skalieren.

Wenn Anti-Bot-Schutzmaßnahmen, CAPTCHAs oder Proxy-Management mehr Zeit in Anspruch nehmen als Ihre eigentliche XPath-Logik, übernimmt WebScrapingAPI die Request-Ebene für Sie und verwaltet Proxy-Rotation sowie Blockierungsmaßnahmen hinter einem einzigen Endpunkt, sodass Sie sich auf saubere Selektoren und die Datenverarbeitung konzentrieren können.