Python ist aufgrund seiner robusten Bibliotheken und einfachen Syntax die erste Wahl für Web Scraping. In diesem Python-Tutorial zum Web-Scraping erkunden wir die Grundlagen der Datenextraktion und führen Sie durch die Einrichtung Ihrer Python-Umgebung, um Ihren ersten Web-Scraper zu erstellen. Wir stellen Ihnen die wichtigsten Bibliotheken vor, die sich für Scraping-Aufgaben eignen, darunter Beautiful Soup, Playwright und lxml.
Es gibt eine Reihe von Python-Bibliotheken, die den Prozess vereinfachen. Im Folgenden sind einige der beliebtesten aufgeführt:
Wenn Sie sich fragen, wie Sie eine Website mit Python scrapen können, müssen Sie zunächst verstehen, wie HTTP-Anfragen funktionieren.
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 Server sendet die Antwort an den Browser zurück, der sie als Webseite wiedergibt. Für Web Scraping müssen Sie diesen Prozess nachahmen und HTTP-Anfragen von Ihrem Skript aus generieren, um den Inhalt von Webseiten programmatisch abzurufen.
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:
PHP
Node.js
Python
Java
Golang
de 
English 
Español 
中國人 
Tiếng Việt 
Українська 
Português 
Français 
भारतीय 
Türkçe 
한국인 
Italiano 
Gaeilge 
اردو 
Indonesia 
Polski
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
Beginnen wir mit einem einfachen Beispiel für die Verwendung von Python zum Scrapen einer Website unter Verwendung der requests-Bibliothek, um statische Inhalte zu extrahieren.
Die gängigste Form der HTTP-Anfrage ist die GET-Anfrage, mit der Daten von einer bestimmten URL abgerufen werden. Hier ist ein einfaches Python-Beispiel für Web-Scraping, das zeigt, wie eine GET-Anfrage an http://example.com durchgeführt wird.
import requests
url = 'http://example.com'
response = requests.get(url)
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)
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!')
Um strukturierte Daten zu extrahieren, helfen Bibliotheken wie Beautiful Soup und lxml dabei, bestimmte Teile der Seite zu identifizieren und zu parsen.
Webseiten bestehen aus verschachtelten Elementen, die durch Tags dargestellt werden, 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 Möglichkeit, Elemente anhand ihrer Attribute oder ihrer Position im Dokument auszuwählen.
Beim Scraping müssen zum Extrahieren bestimmter Daten oft die richtigen XPath- oder CSS-Selektoren ermittelt werden. Hier erfahren Sie, wie Sie diese effizient finden:
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:
XPath: /html/body/div/h1
CSS-Selektor: body > div > h1
Beautiful Soup ist eine Python-Bibliothek zum Parsen von Seiteninhalten. Sie bietet Methoden und Attribute zum Navigieren und Suchen in der Seitenstruktur.
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)
Wie Beautiful Soup erlaubt auch lxml das Abfangen und die elegante Behandlung von Problemen mit Hilfe von Ausnahmen wie lxml.etree.XMLSyntaxError.
Der bereitgestellte "Python Web Scraping Code" führt eine Datenextraktion auf einer Amazon-Produktseite mit Playwright und lxml durch. Er richtet einen Proxy ein und startet einen Browser, navigiert zur Produktseite, interagiert mit Elementen, wartet, bis die Seite vollständig geladen ist, und erfasst die Seitenquelle.
Dieser Inhalt wird mit lxml geparst, um einen Elementbaum zu erstellen, und XPath wird verwendet, um den Produkttitel zu extrahieren. Das Skript behandelt Fälle, in denen das Element nicht gefunden wird oder das Parsen fehlschlägt. Nach dem Scraping wird die Browser-Sitzung ordnungsgemäß geschlossen.
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}')
Eine weitere beliebte Bibliothek zum Parsen von Inhalten ist lxml. BeautifulSoup ist zwar benutzerfreundlich, aber lxml ist schneller und flexibler und daher ideal für leistungsrelevante Aufgaben.
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)
Ä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}')
Sobald Sie erfolgreich Daten 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:
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')
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')
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
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 Python-Web-Scraping-Code führt eine Datenextraktion 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. Im Browserkontext 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. Sobald diese Interaktionen abgeschlossen sind und die Seite vollständig geladen ist, wird der Seiteninhalt erfasst.
Dieser Inhalt wird dann mit der fromstring-Methode in 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 ist so konzipiert, dass es mit Situationen umgehen kann, in denen die XPath-Abfrage keine Ergebnisse liefert, in denen beim Parsen Probleme mit der XML-Syntax auftreten oder in denen etwas anderes unerwartet schief läuft. Am Ende wird der mit lxml extrahierte Produkttitel gedruckt, und sowohl der Browser-Kontext als auch der Browser selbst werden ordnungsgemäß geschlossen, um die Sitzung zu beenden
Die Ausführungsfunktion wird innerhalb einer Playwright-Sitzung ausgeführt, die von sync_playwright gestartet wird, um sicherzustellen, dass der gesamte Prozess in einer kontrollierten Umgebung verwaltet und ausgeführt wird. Diese Struktur gewährleistet Robustheit und Fehlertoleranz bei der Durchführung der Web-Scraping-Aufgabe.
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 fortgeschrittenere Scraping-Anforderungen, insbesondere bei dynamisch geladenen JavaScript-Websites, erweist sich Playwright als äußerst effektiv.
Dieses Python-Tutorial zum Web-Scraping beschreibt praktische Methoden zur automatisierten Datenextraktion mit Bibliotheken wie Beautiful Soup, lxml und Playwright. Technisch gesehen bezeichnet Web Scraping Python die Verwendung von Python-basierten Tools zum systematischen Abrufen und Verarbeiten strukturierter Daten von Websites.
Egal, ob Sie mit statischen Inhalten oder mit JavaScript-gerenderten Seiten arbeiten, es gibt ein Python-Tool für diese Aufgabe. Wenn Sie HTTP-Anfragen lernen, das Parsing beherrschen und die Datenextraktion verstehen, sind Sie bereit, zuverlässige Scraper zu erstellen.
Denken Sie bei Ihren Fortschritten daran, ethische Scraping-Praktiken zu befolgen - respektieren Sie robots.txt, vermeiden Sie die Überlastung von Servern und gehen Sie stets verantwortungsvoll mit Daten um. Mit einer soliden Grundlage können Sie nun selbstbewusst mit der Entwicklung Ihrer eigenen Scraping-Projekte beginnen und das volle Potenzial von Webdaten ausschöpfen.
Bemerkungen: 0