Schritt-für-Schritt-Anleitung zum Web-Scraping mit Python für Anfänger

Python ist aufgrund seiner robusten Bibliotheken und einfachen Syntax die erste Wahl für Web Scraping. In diesem Artikel befassen wir uns mit den Grundlagen des Web Scraping und führen Sie durch die Einrichtung Ihrer Python-Umgebung, um Ihren ersten Web Scraper zu erstellen. Wir stellen Ihnen die wichtigsten Python-Bibliotheken vor, die sich für Scraping-Aufgaben eignen, darunter Beautiful Soup, Playwright und lxml.

Python-Bibliotheken für Web Scraping

Python bietet mehrere Bibliotheken, die das Web Scraping erleichtern. Hier sind einige der am häufigsten verwendeten Bibliotheken:

• requests: eine einfache und elegante HTTP-Bibliothek für Python, mit der HTTP-Anfragen zum Abrufen von Webseiten gesendet werden können.
• Beautiful Soup: eignet sich hervorragend zum Parsen von HTML- und XML-Dokumenten. Es erstellt Parse-Bäume aus dem Seitenquellcode, die das Extrahieren von Daten erleichtern.
• lxml: lxml ist für seine Geschwindigkeit und Effizienz bekannt und eignet sich hervorragend zum Parsen von XML- und HTML-Dokumenten.
• Playwright: ein robustes Tool für das Scraping dynamischer Inhalte und die Interaktion mit Webseiten.

Einführung in HTTP-Anfragen

HTTP (HyperText Transfer Protocol) ist ein Protokoll der Anwendungsschicht für die Übertragung von Daten im Internet. Sie geben eine URL in den Browser ein, der daraufhin eine HTTP-Anfrage erzeugt und sie an den Webserver sendet. Der Webserver sendet dann die HTTP-Antwort an den Browser zurück, die er Ihnen als HTML-Seite wiedergibt. Für Web Scraping müssen Sie diesen Prozess nachahmen und HTTP-Anfragen von Ihrem Skript aus generieren, um den HTTP-Inhalt von Webseiten programmatisch abzurufen.

Einrichten Ihrer Umgebung

Stellen Sie zunächst sicher, dass Sie Python auf Ihrem System installiert haben. Sie können es von der offiziellen Website von Python herunterladen.

Eine virtuelle Umgebung hilft bei der Verwaltung von Abhängigkeiten. Verwenden Sie diese Befehle, um eine virtuelle Umgebung zu erstellen und zu aktivieren:

python -m venv scraping_env
source scraping_env/bin/activate

Installieren Sie anschließend die erforderlichen Pakete mit den folgenden Befehlen:

pip install requests
pip install beautifulsoup4 
pip install lxml

Web Scraper mit Beautiful Soup bauen

Beginnen wir mit einem einfachen Web Scraper, der die Anfrage zum Scrapen statischer HTML-Inhalte verwendet.

HTTP-GET-Anfrage stellen

Die gebräuchlichste Form der HTTP-Anfrage ist die GET-Anfrage, mit der Daten von einer bestimmten URL abgerufen werden. Hier ist ein einfaches Beispiel für eine GET-Anfrage an http://example.com.

import requests
url = 'http://example.com'
response = requests.get(url)

Umgang mit HTTP-Antworten

Die Anfragebibliothek bietet mehrere Möglichkeiten, die Antwort zu verarbeiten:

Statuscode prüfen: Sicherstellen, dass die Anfrage erfolgreich war.

if response.status_code == 200:
    print('Request was successful!')
else:
    print('Request failed with status code:', response.status_code)

Extrahieren von Inhalten: Extrahieren des Text- oder JSON-Inhalts aus der Antwort.

# Inhalt der Antwort als Text abrufen
page_content = response.text
print(page_content)

# Antwortinhalt als JSON abrufen (wenn die Antwort im JSON-Format vorliegt)
json_content = response.json()
print(json_content)

Behandlung von HTTP- und Netzwerkfehlern

HTTP- und Netzwerkfehler können auftreten, wenn eine Ressource nicht erreichbar ist, eine Anfrage eine Zeitüberschreitung aufweist oder der Server einen HTTP-Fehlerstatus zurückgibt (z. B. 404 Not Found, 500 Internal Server Error). Wir können die von Anfragen ausgelösten Ausnahmeobjekte verwenden, um diese Situationen zu behandeln.

import requests

url = 'http://example.com'

try:
    response = requests.get(url, timeout=10)  # Set a timeout for the request
    response.raise_for_status()  # Raises an HTTPError for bad responses
except requests.exceptions.HTTPError as http_err:
    print(f'HTTP error occurred: {http_err}')
except requests.exceptions.ConnectionError:
    print('Failed to connect to the server.')
except requests.exceptions.Timeout:
    print('The request timed out.')
except requests.exceptions.RequestException as req_err:
    print(f'Request error: {req_err}')
else:
    print('Request was successful!')

Extrahieren von Daten aus HTML-Elementen

Für Web Scraping müssen wir oft Daten aus dem HTML-Inhalt extrahieren. In diesem Teil geht es darum, wie man mit einigen Bibliotheken wie Beautiful Soup oder lxml Daten aus HTML-Elementen lokalisiert und extrahiert.

HTML (HyperText Markup Language) ist die Standardauszeichnungssprache zur Erstellung von Webseiten. Sie besteht aus verschachtelten Elementen, die durch Tags wie <div>, <p>, <a>, usw. dargestellt werden. Jedes Tag kann Attribute haben und Text, andere Tags oder beides enthalten.

XPath- und CSS-Selektoren bieten eine vielseitige Möglichkeit, HTML-Elemente anhand ihrer Attribute oder ihrer Position im Dokument auszuwählen.

Suche nach XPath- und CSS-Selektoren

Beim Web-Scraping ist es zum Extrahieren bestimmter Daten aus Webseiten oft erforderlich, die richtigen XPath- oder CSS-Selektoren für die Ziel-HTML-Elemente zu identifizieren. Hier erfahren Sie, wie Sie diese Selektoren effizient finden können:

Die meisten modernen Webbrowser verfügen über integrierte Entwicklerwerkzeuge, mit denen Sie die HTML-Struktur von Webseiten untersuchen können. Im Folgenden finden Sie eine schrittweise Anleitung zur Verwendung dieser Tools:

1. Offene Entwicklerwerkzeuge:
   • In Chrome: Rechtsklick auf die Seite und "Untersuchen" auswählen oder Strg+Umschalt+I (Windows/Linux) bzw. Cmd+Opt+I (Mac) drücken.
   • In Firefox: Rechtsklick auf die Seite und "Element untersuchen" auswählen oder Strg+Umschalt+I (Windows/Linux) bzw. Cmd+Opt+I (Mac) drücken.
2. Überprüfen Sie das Element:
   • Verwenden Sie das Inspektionstool (ein Cursorsymbol), um mit dem Mauszeiger auf das Element zu zeigen, das Sie auslesen möchten, und klicken Sie darauf. Dadurch wird das Element in der HTML-Strukturansicht hervorgehoben.
3. XPath- oder CSS-Selektor kopieren:
   • Klicken Sie mit der rechten Maustaste auf das hervorgehobene HTML-Element im Bereich der Entwicklertools.
   • Wählen Sie "Kopieren" und dann entweder "XPath kopieren" oder "Selektor kopieren" (CSS-Selektor).

XPath: /html/body/div/h1

CSS Selector: body > div > h1

Extraktion mit Beautiful Soup

Beautiful Soup ist eine Python-Bibliothek zum Parsen von HTML- und XML-Dokumenten. Sie bietet einfache Methoden und Attribute zum Navigieren und Suchen in der HTML-Struktur.

from bs4 import BeautifulSoup
import requests

# URL der zu durchsuchenden Webseite
url = 'https://example.com'

# Senden Sie eine HTTP-GET-Anfrage an die URL
response = requests.get(url)

# Analysieren Sie den HTML-Inhalt der Antwort mit Beautiful Soup
soup = BeautifulSoup(response.content, 'html.parser')

# Verwenden Sie den CSS-Selektor, um alle <h1> Tags zu finden, die sich innerhalb von <div> Tags befinden
# die direkte Kinder des Tags <body> sind
h1_tags = soup.select('body > div > h1')

# Iterieren Sie über die Liste der gefundenen <h1> Tags und drucken Sie deren Textinhalt
for tag in h1_tags:
    print(tag.text)

Behandlung von Parsing-Fehlern

Parsing-Fehler treten auf, wenn die HTML- oder XML-Struktur nicht den Erwartungen entspricht, was zu Problemen bei der Datenextraktion führt. Diese können durch die Behandlung von Ausnahmen wie AttributeError verwaltet werden.

from bs4 import BeautifulSoup
import requests

# URL der zu durchsuchenden Webseite
url = 'https://example.com'

# Senden Sie eine HTTP-GET-Anfrage an die URL
response = requests.get(url)

try:
    # Analysieren Sie den HTML-Inhalt der Antwort mit Beautiful Soup
    soup = BeautifulSoup(response.content, 'html.parser')

    # Verwenden Sie den CSS-Selektor, um alle <h1> Tags zu finden, die sich innerhalb von <div> Tags befinden.
    # die direkte Kinder des <body> Tags sind
    h1_tags = soup.select('body > div > h1')

    # Iterieren Sie über die Liste der gefundenen <h1> Tags und drucken Sie deren Textinhalt
    for tag in h1_tags:
        print(tag.text)
except AttributeError as attr_err:
    # Behandlung von Fällen, in denen ein AttributeError auftreten könnte (z. B. wenn der response.content keiner ist)
    print(f'Attribute error occurred: {attr_err}')
except Exception as parse_err:
    # Behandlung sonstiger Ausnahmen, die während des Parsings auftreten können
    print(f'Error while parsing HTML: {parse_err}')

Extraktion mit lxml

Neben Beautiful Soup ist lxml eine weitere beliebte Bibliothek für das Parsen von HTML- und XML-Dokumenten in Python. Während BeautifulSoup sich darauf konzentriert, eine bequeme Schnittstelle für die Navigation und Manipulation geparster Daten bereitzustellen, ist lxml für seine Geschwindigkeit und Flexibilität bekannt, was es zu einer bevorzugten Wahl für leistungsrelevante Aufgaben macht.

from lxml.html import fromstring
import requests

# URL der zu durchsuchenden Webseite
url = 'https://example.com'

# Senden Sie eine HTTP-GET-Anfrage an die URL
response = requests.get(url)

# Parsen des HTML-Inhalts der Antwort mit der fromstring-Methode von lxml
parser = fromstring(response.text)

# Verwenden Sie XPath, um den Textinhalt des ersten <h1> Tags zu finden
# das sich innerhalb eines <div> Tags befindet, der ein direktes Kind des <body> Tags ist
title = parser.xpath('/html/body/div/h1/text()')[0]

# Den Titel drucken
print(title)

Behandlung von Parsing-Fehlern

Ähnlich wie Beautiful Soup erlaubt lxml eine elegante Behandlung von Parsing-Fehlern, indem Ausnahmen wie lxml.etree.XMLSyntaxError abgefangen werden.

from lxml.html import fromstring
from lxml import etree
import requests

# URL der zu durchsuchenden Webseite
url = 'https://example.com'

# Senden Sie eine HTTP-GET-Anfrage an die URL
response = requests.get(url)

try:
    # Parsen des HTML-Inhalts der Antwort mit der fromstring-Methode von lxml
    parser = fromstring(response.text)

    # Verwenden Sie XPath, um den Textinhalt des ersten <h1> Tags zu finden
    # der sich innerhalb eines <div> Tags befindet, der ein direktes Kind des <body> Tags ist
    title = parser.xpath('/html/body/div/h1/text()')[0]

    # Den Titel drucken
    print(title)
except IndexError:
    # Behandlung des Falles, dass die XPath-Abfrage keine Ergebnisse liefert
    print('No <h1> tag found in the specified location.')
except etree.XMLSyntaxError as parse_err:
    # Behandlung von XML-Syntaxfehlern beim Parsen
    print(f'Error while parsing HTML: {parse_err}')
except Exception as e:
    # Behandeln Sie alle anderen Ausnahmen
    print(f'An unexpected error occurred: {e}')

Speichern der extrahierten Daten

Sobald Sie erfolgreich Daten aus HTML-Elementen extrahiert haben, besteht der nächste Schritt darin, diese Daten zu speichern. Python bietet mehrere Optionen zum Speichern von gescrapten Daten, darunter das Speichern in CSV-Dateien, JSON-Dateien und Datenbanken. Hier finden Sie einen Überblick darüber, wie Sie extrahierte Daten in verschiedenen Formaten speichern können:

Speichern von Daten in einer CSV-Datei

CSV (Comma-Separated Values) ist ein einfaches und weit verbreitetes Format zum Speichern von tabellarischen Daten. Das CSV-Modul in Python macht es einfach, Daten in CSV-Dateien zu schreiben.

import csv

# Beispielhafte Daten
data = {
    'title': 'Example Title',
    'paragraphs': ['Paragraph 1', 'Paragraph 2', 'Paragraph 3']
}

# Daten in einer CSV-Datei speichern
with open('scraped_data.csv', mode='w', newline='', encoding='utf-8') as file:
    writer = csv.writer(file)
    writer.writerow(['Title', 'Paragraph'])
    for paragraph in data['paragraphs']:
        writer.writerow([data['title'], paragraph])

print('Data saved to scraped_data.csv')

Speichern von Daten in einer JSON-Datei

JSON (JavaScript Object Notation) ist ein leichtgewichtiges Format für den Datenaustausch, das einfach zu lesen und zu schreiben ist. Das JSON-Modul in Python bietet Methoden zum Speichern von Daten im JSON-Format.

import json

# Beispielhafte Daten
data = {
    'title': 'Example Title',
    'paragraphs': ['Paragraph 1', 'Paragraph 2', 'Paragraph 3']
}

# Daten in einer JSON-Datei speichern
with open('scraped_data.json', mode='w', encoding='utf-8') as file:
    json.dump(data, file, ensure_ascii=False, indent=4)

print('Data saved to scraped_data.json')

Erweiterte Web-Scraping-Techniken mit Playwright

Playwright ist ein leistungsfähiges Tool für das Scraping dynamischer Inhalte und die Interaktion mit Webelementen. Es kann JavaScript-lastige Websites verarbeiten, was statische HTML-Parser nicht können.

Installieren Sie Playwright und richten Sie es ein:

pip install playwright
playwright install

Scraping dynamischer Inhalte

Mit Playwright können Sie mit Web-Elementen interagieren, z. B. Formulare ausfüllen und auf Schaltflächen klicken. Es kann auf die Fertigstellung von AJAX-Anfragen warten, bevor es fortfährt, was es ideal für das Scraping dynamischer Inhalte macht.

Der bereitgestellte Code führt Web Scraping auf einer Amazon-Produktseite mit Playwright und lxml durch. Zu Beginn werden die erforderlichen Module importiert. Eine Lauffunktion wird definiert, um die Scraping-Logik zu kapseln. Die Funktion beginnt mit dem Einrichten eines Proxy-Servers und dem Starten einer neuen Browser-Instanz mit dem Proxy und im Non-Headless-Modus, damit wir die Browser-Aktionen beobachten können. Innerhalb des Browserkontexts wird eine neue Seite geöffnet und zur angegebenen Amazon-Produkt-URL navigiert, wobei eine Zeitüberschreitung von 60 Sekunden vorgesehen ist, um sicherzustellen, dass die Seite vollständig geladen wird.

Das Skript interagiert dann mit der Seite, um einen bestimmten Produktstil aus einem Dropdown-Menü und eine Produktoption mit Hilfe von Locators und Textabgleich auszuwählen. Nachdem sichergestellt ist, dass diese Interaktionen abgeschlossen sind und die Seite wieder vollständig geladen wurde, wird der HTML-Inhalt der Seite erfasst.

Der HTML-Inhalt wird dann mit der fromstring-Methode von lxml geparst, um einen Elementbaum zu erstellen. Eine XPath-Abfrage wird verwendet, um den Textinhalt des Produkttitels aus einem bestimmten Element mit der ID productTitle zu extrahieren. Das Skript enthält eine Fehlerbehandlung für den Fall, dass die XPath-Abfrage keine Ergebnisse liefert, beim Parsen XML-Syntaxfehler auftreten oder andere unerwartete Ausnahmen auftreten. Schließlich wird der von tlxml extrahierte Produkttitel gedruckt und der Browser-Kontext und der Browser werden geschlossen, um die Sitzung zu beenden.

The run function is executed within a Playwright session started by sync_playwright, ensuring that the entire process is managed and executed within a controlled environment. This structure ensures robustness and error resilience while performing the web scraping task.

from playwright.sync_api import Playwright, sync_playwright
from lxml.html import fromstring, etree


def run(playwright: Playwright) -> None:
   # Definieren Sie den Proxyserver
   proxy = {"server": "https://IP:PORT", "username": "LOGIN", "password": "PASSWORD"}

   # Eine neue Browserinstanz mit dem angegebenen Proxy und im nicht-kopflosen Modus starten
   browser = playwright.chromium.launch(
       headless=False,
       proxy=proxy,
       slow_mo=50,
       args=['--ignore-certificate-errors'],
   )

   # Erstellen Sie einen neuen Browser-Kontext
   context = browser.new_context(ignore_https_errors=True)

   # Eine neue Seite im Browser-Kontext öffnen
   page = context.new_page()

   # Navigieren Sie zu der angegebenen Amazon-Produktseite
   page.goto(
       "https://www.amazon.com/A315-24P-R7VH-Display-Quad-Core-Processor-Graphics/dp/B0BS4BP8FB/",
       timeout=10000,
   )

   # Warten, bis die Seite vollständig geladen ist
   page.wait_for_load_state("load")

   # Wählen Sie einen bestimmten Produktstil aus dem Dropdown-Menü
   page.locator("#dropdown_selected_style_name").click()

   # Wählen Sie eine bestimmte Produktoption
   page.click('//*[@id="native_dropdown_selected_style_name_1"]')
   page.wait_for_load_state("load")

   # Abrufen des HTML-Inhalts der geladenen Seite
   html_content = page.content()

   try:
       # Parsen des HTML-Inhalts mit der fromstring-Methode von lxml
       parser = fromstring(html_content)

       # XPath verwenden, um den Textinhalt des Produkttitels zu extrahieren
       product_title = parser.xpath('//span[@id="productTitle"]/text()')[0].strip()

       # Drucken des extrahierten Produkttitels
       print({"Product Title": product_title})
   except IndexError:
       # Behandlung des Falles, dass die XPath-Abfrage keine Ergebnisse liefert
       print('Product title not found in the specified location.')
   except etree.XMLSyntaxError as parse_err:
       # Behandlung von XML-Syntaxfehlern beim Parsen
       print(f'Error while parsing HTML: {parse_err}')
   except Exception as e:
       # Behandeln Sie alle anderen Ausnahmen
       print(f'An unexpected error occurred: {e}')

   # Schließen Sie den Browser-Kontext und den Browser
   context.close()
   browser.close()


# Verwenden Sie sync_playwright, um die Playwright-Sitzung zu starten und das Skript auszuführen
with sync_playwright() as playwright:
   run(playwright)

Web-Scraping mit Python ist eine leistungsstarke Methode zum Sammeln von Daten aus Websites. Die besprochenen Tools erleichtern die Extraktion, Verarbeitung und Speicherung von Webdaten für verschiedene Zwecke. Dabei sind die Verwendung von Proxy-Servern zum Wechseln von IP-Adressen und die Implementierung von Verzögerungen zwischen den Anfragen entscheidend für die Umgehung von Sperren. Beautiful Soup ist benutzerfreundlich für Anfänger, während lxml dank seiner Effizienz für die Verarbeitung großer Datenmengen geeignet ist. Für fortgeschrittene Scraping-Anforderungen, insbesondere bei dynamisch geladenen JavaScript-Websites, erweist sich Playwright als äußerst effektiv.