So verwenden Sie XPath-Selektoren für Web Scraping in Python

Wenn Sie mit Python Daten aus Webseiten extrahieren möchten, ist XPath ein unverzichtbares Tool in Ihrem Web-Scraping-Toolkit. XPath bietet eine Möglichkeit, durch die HTML-Struktur einer Seite zu navigieren und genau die Elemente und Daten zu finden, die Sie benötigen.

In diesem Leitfaden gehen wir durch die Grundlagen von XPath und zeigen, wie Sie seine Leistungsfähigkeit für Web Scraping mit Python nutzen können. Am Ende sind Sie bereit, eine Vielzahl von Scraping-Aufgaben mit XPath zu bewältigen, um die gewünschten Daten chirurgisch zu extrahieren.

Was ist XPath?

XPath steht für XML Path Language. Es handelt sich um eine Abfragesprache zum Auswählen von Knoten aus einem XML- oder HTML-Dokument. Mit XPath geben Sie ein Muster an, das mit der Dokumentstruktur abgeglichen werden soll, und es werden alle Elemente zurückgegeben, die mit diesem Muster übereinstimmen.

Obwohl XPath ursprünglich für XML entwickelt wurde, funktioniert es genauso gut mit HTML und eignet sich daher ideal für Web-Scraping-Zwecke. Es bietet eine leistungsfähigere und flexiblere Alternative zu CSS-Selektoren oder regulären Ausdrücken.

Grundlagen der XPath-Syntax

Um XPath verwenden zu können, müssen Sie die Bausteine ​​der XPath-Syntax verstehen. Hier sind die Schlüsselkonzepte:

Auswählen von Knoten nach Tag-Namen

Der einfachste XPath-Ausdruck besteht darin, einfach einen Tag-Namen anzugeben. Zum Beispiel:

• //h1 wählt alle aus <h1> Überschriftenelemente auf der Seite
• //p wählt alle aus <p> Absatzelemente
• //img wählt alle aus <img> Bildelemente

Auswählen von Knoten nach Attribut

Mit können Sie Elemente auswählen, die ein bestimmtes Attribut oder einen bestimmten Attributwert haben @ Syntax:

• //*[@class="highlighted"] wählt alle Elemente aus, die die Klasse „hervorgehoben“ haben
• //a[@href] wählt alle aus <a> Ankerelemente, die ein href-Attribut haben
• //img[@alt="Logo"] wählt aus <img> Elemente mit dem Alternativtext „Logo“

Knoten nach Position auswählen

Sie können Knoten anhand ihrer Position mithilfe von eckigen Klammern auswählen [] und ein numerischer Index:

• //ul/li[1] wählt den ersten aus <li> Element in jedem <ul> ungeordnete Liste
• //table/tr[last()] wählt den letzten aus <tr> Zeile in jeder <table>
• //ol/li[position() <= 3] wählt die ersten drei aus <li> Artikel in jedem <ol> Bestellliste

Auswählen von Knoten nach Beziehung

Mit XPath können Sie im Dokumentbaum nach oben und unten navigieren, um Elemente basierend auf ihren Vorfahren, Nachkommen, Geschwistern usw. auszuwählen:

• //div[@class="content"]/* wählt alle untergeordneten Elemente von aus <div> Elemente mit der Klasse „content“
• //p/.. wählt die übergeordneten Elemente von allen aus <p> Absätze
• //h1/following-sibling::p wählt alle aus <p> Elemente, die Geschwister nach einem sind <h1> Üerschrift
• //section//img wählt alle aus <img> Elemente, die Nachkommen von a sind <section> auf jeder Ebene

Prädikate und Funktionen

XPath unterstützt eine breite Palette von Prädikaten und Funktionen, um Ihre Auswahl weiter zu verfeinern:

• //p[contains(text(),"scrapy")] wählt aus <p> Elemente, die den Text „scrapy“ enthalten
• //a[starts-with(@href,"https")] wählt aus <a> Elemente, bei denen die href mit „https“ beginnt
• //ul[count(li) > 10] wählt aus <ul> Elemente, die mehr als 10 enthalten <li> Artikel
• //img[string-length(@alt) > 0] wählt aus <img> Elemente mit einem nicht leeren Alt-Attribut

Verwendung von XPath mit lxml und BeautifulSoup

Nachdem Sie nun die Grundlagen der XPath-Syntax verstanden haben, sehen wir uns an, wie Sie sie in Python mit den beliebten Bibliotheken lxml und BeautifulSoup verwenden können. Wir werden ein Beispiel für das Scrapen des Hauptüberschriftentextes von der ScrapingBee-Homepage durchgehen.

Parsen von HTML mit lxml und BeautifulSoup

Zuerst müssen wir den HTML-Code der Webseite mithilfe der Anforderungsbibliothek abrufen und ihn in eine Baumstruktur analysieren, die wir mit XPath abfragen können. Wir verwenden BeautifulSoup, um den HTML- und LXML-Code zu analysieren und unsere XPath-Ausdrücke auszuwerten:

import requests
from bs4 import BeautifulSoup
from lxml import etree

html = requests.get("https://scrapingbee.com") 
soup = BeautifulSoup(html.text, "html.parser")
dom = etree.HTML(str(soup))

Hier wir:

1. Rufen Sie den HTML-Code mit ab requests.get()
2. Analysieren Sie die HTML-Zeichenfolge mithilfe des html.parser in ein BeautifulSoup-Objekt
3. Konvertieren Sie das BeautifulSoup-Objekt in einen String, damit wir es mit lxmls analysieren können etree.HTML() Funktion
4. Analysieren Sie die Zeichenfolge in eine LXML Element Objekt, das wir mit XPath abfragen können

Erstellen und Auswerten von XPath-Ausdrücken

Nachdem wir nun einen analysierten HTML-Baum haben, können wir einen XPath-Ausdruck erstellen, um den Hauptbaum auszuwählen <h1> Überschrift auf der Seite:

heading_xpath = ‘//h1‘

Um diesen XPath anhand unseres analysierten HTML-Dokuments auszuwerten, verwenden wir den xpath() Verfahren:

heading_elements = dom.xpath(heading_xpath)

Das dom.xpath() Der Aufruf gibt eine Liste aller Elemente zurück, die unserem XPath-Selektor entsprechen. In diesem Fall sollte es nur eine Übereinstimmung geben <h1> Element.

Extrahieren von Text und Attributen

Sobald wir einen Verweis auf das Element haben, können wir seinen Text und alle Attribute mithilfe der Eigenschaften von lxml einfach extrahieren:

heading_text = heading_elements[0].text
print(heading_text)
# Tired of getting blocked while scraping the web?  

Wir haben den Überschriftentext erfolgreich mit nur einer einzigen XPath-Zeile extrahiert! Wir könnten mit auch auf Attributwerte des Elements zugreifen get():

heading_id = heading_elements[0].get(‘id‘)  

Verwendung von XPath mit Selenium

Ein alternativer Ansatz besteht darin, Selenium zum Automatisieren und Scrapen dynamischer Websites zu verwenden, die JavaScript erfordern. Selenium bietet eigene Methoden zur Auswahl von Elementen mithilfe von XPath-Strings.

Selenium WebDriver konfigurieren

Um mit Selenium zu beginnen, müssen Sie zunächst das Selenium-Paket und einen Webtreiber für den Browser installieren, den Sie verwenden möchten. So können Sie einen Chrome-Treiber konfigurieren:

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

driver_path = "/path/to/chromedriver"  
driver = webdriver.Chrome(driver_path)

Stellen Sie sicher, dass Sie die entsprechende ChromeDriver-Version für Ihre Chrome-Installation herunterladen und den Pfad zur ausführbaren Datei angeben.

Elemente mit XPath finden

Wenn der Treiber konfiguriert ist, können wir zu einer Webseite navigieren und mit der Suche nach Elementen beginnen. Der WebDriver von Selenium bietet eine find_element Methode, die einen XPath-Locator akzeptiert:

driver.get("https://scrapingbee.com")

heading_xpath = "//h1"
heading_element = driver.find_element(By.XPATH, heading_xpath)

Ähnlich wie im lxml-Beispiel wird hiermit das erste gefunden <h1> Element auf der Seite. Wenn Sie alle Elemente finden möchten, die einem XPath entsprechen, verwenden Sie find_elements stattdessen:

paragraph_xpath = "//p"
paragraph_elements = driver.find_elements(By.XPATH, paragraph_xpath)  

Extrahieren von Text und Attributen

Sobald Sie einen Verweis auf ein Webelement haben, können Sie auf dessen Eigenschaften wie Textinhalte und Attribute zugreifen:

heading_text = heading_element.text
print(heading_text)  
# Tired of getting blocked while scraping the web?

paragraph_id = paragraph_elements[0].get_attribute("id")

Das Extrahieren von Daten mit Selenium und XPath ist recht einfach. Bedenken Sie jedoch, dass Selenium im Allgemeinen langsamer ist als die Verwendung einer einfachen HTTP-Anforderungsbibliothek, da es einen tatsächlichen Browser ausführt.

Tipps und Best Practices

Wenn Sie XPath zum Web-Scraping verwenden, sollten Sie die folgenden Tipps und Tricks beachten:

Verwenden Sie Chrome DevTools, um XPath-Ausdrücke zu testen

Beim Erstellen von XPath-Selektoren ist es sehr nützlich, sie interaktiv zu testen, um sicherzustellen, dass sie Ihren Erwartungen entsprechen. Die Chrome DevTools bieten eine einfache Möglichkeit, dies zu tun:

1. Klicken Sie mit der rechten Maustaste auf ein Element und wählen Sie „Inspizieren“, um das DevTools-Elementfenster zu öffnen
2. Drücken Sie Strg+F, um das Suchfeld zu öffnen
3. Geben Sie Ihren XPath-Ausdruck ein, um übereinstimmende Elemente auf der Seite hervorzuheben

Behandeln Sie inkonsistentes Markup

Websites in freier Wildbahn weisen häufig inkonsistente oder fehlerhafte HTML-Markups auf, die Ihre XPath-Selektoren zum Stolpern bringen können. Es ist eine gute Idee, eine Bibliothek wie BeautifulSoup zu verwenden, um den HTML-Code zu bereinigen und zu normalisieren, bevor er mit lxml analysiert wird.

Schreiben Sie robusten und wartbaren XPath

Um das Risiko zu minimieren, dass Ihr Scraper aufgrund von Layoutänderungen auf der Zielseite kaputt geht, versuchen Sie, XPath-Ausdrücke zu schreiben, die so spezifisch wie möglich, aber nicht spezifischer als nötig sind. Bevorzugen Sie die Auswahl nach semantischen Eigenschaften wie Tag-Namen, IDs und Datenattributen, anstatt sich auf die spezifische Struktur des Markups zu verlassen.

Es empfiehlt sich außerdem, komplexe XPath-Ausdrücke in Variablen mit beschreibenden Namen aufzuteilen, um die Lesbarkeit und Wartbarkeit zu verbessern.

Cache-Ergebnisse zur Verbesserung der Leistung

Wenn Sie große Datenmengen extrahieren oder mehrmals auf dieselben Seiten zugreifen, sollten Sie erwägen, die analysierten HTML- und XPath-Ergebnisse zwischenzuspeichern, um unnötige Netzwerkanfragen und Analyseaufwand zu vermeiden. Sie können zum Caching ein einfaches Wörterbuch oder eine robustere Lösung wie MongoDB oder Redis verwenden.

Zusammenfassung

XPath ist ein unglaublich leistungsstarkes Tool zum präzisen Extrahieren von Daten aus HTML-Seiten. Mit einem grundlegenden Verständnis der Syntax und der Fähigkeit, CSS-Selektoren in ihre XPath-Äquivalente zu übersetzen, können Sie eine Vielzahl von Web-Scraping-Aufgaben bewältigen.

Python-Bibliotheken wie lxml, BeautifulSoup und Selenium bieten einfache Möglichkeiten, XPath in Ihre Scraping-Workflows zu integrieren. Abhängig von Ihren spezifischen Anforderungen und den Merkmalen der Zielseite können Sie den Ansatz wählen, der am besten funktioniert.

Wenn Sie Ihre Web-Scraping-Reise mit Python und XPath fortsetzen, achten Sie stets darauf, die Nutzungsbedingungen der Website und die Einschränkungen von robots.txt zu respektieren. Und denken Sie daran, die Grundlagen der XPath-Funktionen und -Operatoren aufzufrischen – Sie werden erstaunt sein, wie viel Sie mit nur wenigen Zeilen cleverem XPath erreichen können!