Um Du Web Scraping in Python mit BeautifulSoup, du benötigst zwei Bibliotheken: requests um die Webseite herunterzuladen, und beautifulsoup4 um die Daten aus dem HTML-Code zu extrahieren.
Installiere sie mit dem Befehl pip install requests beautifulsoup4, und folge dann der nachstehenden Anleitung, um eine Website Schritt für Schritt zu scrapen.
Voraussetzungen für das Scraping von Python mit BeautifulSoup
Bevor du loslegst, musst du kein Experte sein. Du musst lediglich wissen, wie man ein Skript liest und ausführt. Python Das reicht für den Anfang völlig aus.
Folgendes muss installiert werden, um loszulegen:
- Installieren Python sowie eine Entwicklungsumgebung.
- Installieren pip, das Tool, mit dem sich Python-Bibliotheken mit einem einzigen Befehl hinzufügen lassen.
- Installieren BeautifulSoup :
pip install beautifulsoup4Achten Sie auf den Namen des Pakets: auf PyPI, das ist richtig beautifulsoup4 das muss geschrieben werden. Das Modul, das du in deinen Code importieren wirst, heißt bs4.
- Installieren Requests zum Herunterladen der Webseiten:
pip install requests- Installieren lxml (optional), ein schnellerer Parser, den BeautifulSoup zum Analysieren des HTML-Codes verwendet:
pip install lxmlWie kann man mit Python und BeautifulSoup Web Scraping betreiben?
Hier ist ein vollständiges Projekt zur Wiederherstellung des Titel einer Webseite und alle Links die darin enthalten ist.
Schritt 1: Seiteninhalt mit Requests abrufen
Um eine Webseite herunterzuladen, sendest du eine HTTP GET-Anfrage zu einer URL. Das ist die Aufgabe der Bibliothek Requests.
Bei jeder Anfrage sendet der Server eine Statuscode das dir anzeigt, ob alles gut gelaufen ist. Die wichtigsten, die du kennen solltest:
- 200 : Erfolg.
- 301 / 302 : Umleitung.
- 404 : Seite nicht gefunden.
- 500 : interner Fehler des Servers.
Mit Requests, du überprüfst dieses Ergebnis mithilfe des Attributs .status_code. Hier ein konkretes Beispiel: Dieser Code sendet eine Anfrage an eine Website, überprüft den Statuscode und zeigt dann einen Ausschnitt des HTML-Inhalts an, wenn alles in Ordnung ist.
import requests
# Ziel-URL
url = "https://bonjour.com"
# Senden Sie eine GET-Anfrage.
response = requests.get(url)
# Überprüfen Sie den Statuscode.
if response.status_code == 200:
print("Erfolgreich: Die Seite wurde erfolgreich abgerufen!")
html = response.text # HTML-Inhalt der Seite.
print("Auszug aus dem HTML-Inhalt:")
print(html[:500]) # zeigt nur die ersten 500 Zeichen an.
else:
print(f "Fehler: Statuscode {response.status_code}")
Schritt 2: Analysieren Sie den HTML-Code mit BeautifulSoup
Wenn du den Inhalt einer Seite mit response.text, erhältst du eine einfache Zeichenkette: den gesamten HTML-Code auf der Seite, aber in dieser Form nicht verwertbar. Um es einfach bearbeiten zu können, erstellst du ein Objekt BeautifulSoup, das diesen rohen HTML-Code in eine Struktur umwandelt, die du durchlaufen und analysieren kannst.
Bezeichnet immer ein parseur, zum Beispiel "html.parser". BeautifulSoup interpretiert das HTML dann korrekt, ohne eine Warnung anzuzeigen. Du kannst auch Folgendes verwenden: lxml, schneller, muss separat installiert werden.
from bs4 import BeautifulSoup
import requests
url = "https://bonjour.com"
response = requests.get(url)
html = response.text
# Die Angabe des Parsers wird empfohlen.
soup = BeautifulSoup(html, "html.parser")
Schritt 3: Elemente finden und extrahieren
Das HTML ist nun ein BeautifulSoup-Objekt. Du kannst die Daten die dich interessieren, Tag für Tag. Drei Methoden decken den Großteil der Anforderungen ab.
Verwendung von find() und find_all()
find() gibt das zurück erstes Element gefunden. find_all() gibt die vollständige Liste die entsprechenden Elemente.
# Titel abrufen <h1>
h1 = soup.find("h1")
print(h1.get_text())
# Alle Links abrufen <a>
links = soup.find_all("a")
for lien in links:
print(lien.get_text(), lien.get("href"))
Elemente nach Attributen anvisieren
Du kannst die Suche nach einem HTML-Attribut verfeinern, zum Beispiel Klasse, Ausweis oder irgendein anderes. Notieren : In Python schreibt man class_ und nein Klasse, um einen Konflikt mit dem reservierten Schlüsselwort der Sprache zu vermeiden.
# Ein "div"-Element mit einer bestimmten ID abrufen
container = soup.find("div",)
# Alle Links mit einer bestimmten Klasse abrufen
nav_links = soup.find_all("a", class_="nav-link")
CSS-Selektoren mit `select()` verwenden
Für eine genauere Suche empfiehlt sich die Methode select() akzeptiert CSS-Selektoren. Du kannst bestimmte Teile einer Seite gezielt ansprechen, ohne den gesamten HTML-Code manuell durchgehen zu müssen.
# Alle Links in Artikelüberschriften.
artikel_links = soup.select("artikel h2 a")
# Alle <a> deren href-Attribut mit "http" beginnt.
links_http = soup.select('a[href^="http"]')
Wie extrahiert man Daten aus einer HTML-Tabelle mit BeautifulSoup?
Die tatsächlichen Anwendungsfälle sind oft komplexer als das Abrufen eines Titels oder eines Links. Du wirst dich mit der’Extraktion von strukturierten Daten wie Tabellen und Listen, die Seitenumbruch, sowie häufige Fehler beim Scraping.
Tabellen und Listen extrahieren
Webseiten präsentieren ihre Daten oft in HTML-Tabellen (<table>, <tr>, <th>, <td>) oder der Listen (
Um ein HTML-TabelleDas Prinzip ist einfach:
- Kopfzeilen abrufen (
<th>), um die Spaltenüberschriften zu identifizieren. - Jede Zeile durchgehen (
<tr>) und nach Zellen suchen (<td>), die die Daten enthalten. - Die Informationen in einer Liste oder einem Wörterbuch speichern.
Für eine HTML-Liste (
- Alle Tags markieren
- .
- Ihren Inhalt (Text oder Link) abrufen und in eine Python-Liste einfügen.
Hier ein Beispiel mit einer Tabelle :
html = """
<table>
<tr>
<th>Nachname</th>
<th>Alter</th>
<th>Stadt, Dorf</th>
</tr>
<tr>
<td>Alice</td>
<td>25</td>
<td>Paris</td>
</tr>
<tr>
<td>Bob</td>
<td>30</td>
<td>Lyon</td>
</tr>
</table>
"""
# Erstellen Sie das Objekt BeautifulSoup.
soup = BeautifulSoup(html, "html.parser")
# Extrahieren Sie die Überschriften aus dem Array.
headers = [th.get_text(strip=True) for th in soup.find_all("th")]
print("Überschriften:", headers)
# Datenzeilen extrahieren (die erste Zeile wird übersprungen, da dies die Überschriften sind).
rows = []
for tr in soup.find_all("tr")[1:]:
cells = [td.get_text(strip=True) for td in tr.find_all("td")]
if cells:
rows.append(cells)
print("Zeilen:", rows)
Hier, find_all("th") ruft die Kopfzeilen und find_all("td") Liest die Zellen jeder Zeile aus. Du durchläufst die <tr> um die Tabelle Zeile für Zeile neu aufzubauen.
Hier ein Beispiel auf einer Liste:
from bs4 import BeautifulSoup
html_list = """
- Apfel
- Banane
- Orange
.
.
"""
soup = BeautifulSoup(html_list, "html.parser")
# Elemente aus der Liste abrufen
items = [li.get_text(strip=True) for li in soup.find_all("li")]
print("Liste abgerufen:", items) # ["Apfel", "Banane", "Orange"]
Jede ["Apfel", "Banane", "Orange"].
Paginierung und Links verwalten
Oft passen die Daten nicht auf eine einzige Seite. Sie werden über Links verteilt, die „nächste Seite“ oder ein nummerierte Paginierung (?Seite=1, ?Seite=2, usw.). In beiden Fällen musst du loop um alle Seiten abzurufen und die Daten zusammenzuführen.
Beispiel mit einem Seitenparameter:
import time
import requests
from bs4 import BeautifulSoup
# Beispiel-URL mit Paginierung
BASE_URL = "https://bonjour.com/articles?page={}"
HEADERS = {"User-Agent": "Mozilla/5.0"}
all_articles = []
# Es wird angenommen, dass 5 Seiten durchsucht werden müssen.
for page in range(1, 6):
url = BASE_URL.format(page)
r = requests.get(url, headers=HEADERS, timeout=20)
if r.status_code == 200:
soup = BeautifulSoup(r.text, "html.parser")
# Titel von Artikeln extrahieren.
articles = [h2.get_text(strip=True) for h2 in soup.find_all("h2", class_="title")]
all_articles.extend(artikel)
else:
print(f "Fehler auf Seite {page} (Code: {r.status_code})")
time.sleep(1.0) # politeness
print("Artikel abgerufen:", all_articles)Eine kurze Schritt-für-Schritt-Anleitung:
- Bereite das’URL mit einem Stellplatz
{}um die Seitenzahl einzufügen.
BASE_URL = "https://bonjour.com/articles?page={}- Manche Websites blockieren Anfragen ohne Browser-Identität. Fügen Sie ein User-Agent Vermeide es, für einen Bot gehalten zu werden.
headers = {"User-Agent": "Mozilla/5.0"}
requests.get(url, headers=headers) - Seitenanfang 1 bis 5.
for page in range(1, 6):- Ruft den HTML-Code der Seite ab mit requests.
requests.get(url)- Begrenzt die Wartezeit, wenn die Website nicht reagiert (20-Sekunden-Timeout).
requests.get(url, timeout=20)- Die Seite analysieren mit BeautifulSoup.
BeautifulSoup(response.text, "html.parser")- Ruft alle Artikeltitel.
find_all("h2", class_="title")- Fügt die gefundenen Artikel zu einer Gesamtliste hinzu.
all_articles.extend(Artikel)- Gib eine Pause zwischen jeder Anfrage, um den Server nicht zu überlasten und eine Sperrung zu vermeiden.
time.sleep(1.0)Nach der Schleife, all_articles enthält alle Titel der 5 Seiten.
Häufige Fehler und Herausforderungen
Scraping ist nicht einfach nur ein Knopfdruck. Dabei wirst du häufig auf Hindernisse stoßen:
- HTTP-Fehler : 404 (Seite nicht gefunden), 403 (Zutritt verboten) und 500 (Fehler auf der Serverseite).
Beispiel für die Verwaltung:
response = requests.get(url)
if response.status_code == 200:
print("Seite erfolgreich abgerufen")
elif response.status_code == 404:
print("Fehler: Seite nicht gefunden")
else:
print("Zurückgegebener Statuscode:", response.status_code)
- Websites, die das Scraping blockieren : Manche erkennen automatisierte Anfragen und sperren den Zugriff.
- Dynamische Seiten (JavaScript) : BeautifulSoup liest nur das Statisches HTML. Wenn die Seite ihren Inhalt mit JavaScript lädt, siehst du nichts. In diesem Fall musst du ein Tool wie Selenium Wo Playwright.
Um effektiv zu scrapen, ohne gesperrt zu werden oder die Website zu beschädigen, solltest du folgende bewährte Vorgehensweisen beachten:
- Beachte die robots.txt-Datei der Website, die du analysieren möchtest.
- Richte folgende Maßnahmen ein: Fristen zwischen den Abfragen mit
time.sleep()um den Server nicht zu überlasten. - Verwende Proxies und lass sie sich drehen.
- Wechsle regelmäßig dein User-Agent.
Wie kann man mit Selenium und BeautifulSoup Web Scraping betreiben?
Selenium kontrolliert einen echten Browser, führt das JavaScript aus und zeigt die Seite so an, als würde ein Mensch darauf navigieren. BeautifulSoup Anschließend analysierst du den HTML-Code, sobald die Seite vollständig gerendert ist, und extrahierst alle gewünschten Daten.
Schritt 1: Selenium und BeautifulSoup installieren
Hier, anstelle von requests, du verwendest Selenium um den Inhalt der Seite abzurufen. Installiere die beiden Bibliotheken mit diesem Befehl:
pip install selenium beautifulsoup4Anschließend musst du eine WebDriver angepasst an die Version deines Browsers. Für Google Chrome lautet sie ChromeDriver. Du hast zwei Möglichkeiten: Du kannst es entweder im selben Ordner wie dein Python-Skript ablegen oder es’Zur Umgebungsvariable PATH hinzufügen deines Systems.
Schritt 2: Selenium konfigurieren
Fang damit an, zu importieren webdriver über Selenium zur Steuerung des Browsers.
from selenium import webdriver
from selenium.webdriver.common.by import ByÖffne anschließend einen Browser. Dieser öffnet die Seite und führt das JavaScript aus, hier Chrome.
driver = webdriver.Chrome()Gibt dem Browser an, welche URL besuchen.
driver.get("https://www.exemple.com")Wenn die Seite bei der Anzeige bestimmter Elemente etwas Zeit benötigt, kannst du Selenium anweisen, bis zu 10 Sekunden.
driver.implicitly_wait(10)Schritt 3: Abrufen des Seiteninhalts
Sobald die Seite geladen ist, rufst du das Vollständiger DOM : Der HTML-Quellcode, der nach Ausführung des JavaScript-Codes entsteht.
html_content = driver.page_sourceSchritt 4: HTML-Analyse mit BeautifulSoup
Leite diesen Quellcode nun weiter an BeautifulSoup um sie zu nutzen:
from bs4 import BeautifulSoup
# Ein BeautifulSoup-Objekt erstellen
soup = BeautifulSoup(html_content, 'html.parser')
# Beispiel: Alle Überschriften der Seite abrufen
titres = soup.find_all('h2')
for titre in titres:
print(titre.get_text())BeautifulSoup bietet leistungsstarke Methoden wie find(), find_all() und die CSS-Selektoren für auswählen und extrahieren bestimmte HTML-Elemente.
Schritt 5: Schließen des Browsers
Sehr wichtig: Schließe deinen Browser nach der Ausführung immer, um Ressourcen freisetzen.
driver.quit()So kombinierst du die Leistungsfähigkeit von Selenium zum eine menschliche Navigation simulieren (Klicks, Bildlauf) kombiniert mit der Effizienz von BeautifulSoup bei der HTML-Analyse. Dies ist die ideale Methode, um eine Website zu scrapen, deren Daten über JavaScript geladen werden.
Häufig gestellte Fragen
Welches ist das beste Tool für Web Scraping in Python?
Es gibt kein’Scraping-Werkzeug keine allgemeingültigen Lösungen, sondern vielmehr Lösungen, die auf dein Projekt zugeschnitten sind. Hier sind die drei am häufigsten verwendeten:
- BeautifulSoup : Einfach und effizient, um HTML zu analysieren und Inhalte schnell zu extrahieren. Ideal, wenn du gerade erst anfängst oder kleine Projekte hast.
- Scrapy : ein umfassendes Framework, das für die Verwaltung von große Datenmengen mit erweiterten Funktionen.
- Playwright : Ideal für komplexe, mit JavaScript erstellte Websites. Es simuliert einen echten Browser und interagiert mit der Seite wie ein Mensch.
Wie kann man mit BeautifulSoup den Inhalt eines div-Tags extrahieren?
Mit BeautifulSoup, du wählst ein bestimmtes Tag mithilfe eines CSS-Selektor. So extrahieren Sie den Inhalt eines Tags <div>, befolge diese Schritte.
1. Die Webseite abrufen mit requests, und anschließend den HTML-Code mit BeautifulSoup.
from bs4 import BeautifulSoup
import requests
url = "URL_DE_TON_SITE" # Remplace par l'URL réelle
reponse = requests.get(url)
html_content = reponse.text
soup = BeautifulSoup(html_content, "html.parser")2. Die Methode anwenden select() mit deinem CSS-Selektor, um das Tag anzusprechen <div>.
Um das erste Element abzurufen, verwende soup.select_one. Um alle Elemente abzurufen, verwende soup.select. Hier ist ein Beispiel für HTML-Code:
<div>
<h2>Titre de l'article</h2>
<p>Voici le contenu du paragraphe.</p>
</div>Und hier ist das Beispiel mit dem CSS-Selektor div.artikel :
# Récupérer le premier div avec la classe "article"
div_article = soup.select_one("div.article")
# Afficher son contenu texte
if div_article:
print(div_article.get_text(strip=True))3. Die Gegenstände aus dem Inneren der <div>.
# Récupérer le titre à l'intérieur du div
titre = soup.select_one("div.article h2").get_text()
# Récupérer le paragraphe à l'intérieur du div
paragraphe = soup.select_one("div.article p").get_text()
print("Titre :", titre)
print("Paragraphe :", paragraphe)Wie kann ich Requests und BeautifulSoup zusammen verwenden?
Diese beiden Bibliotheken sind ergänzend : Die eine lädt die Seite herunter, die andere analysiert sie.
1. requests sendet eine HTTP-Anfrage und lädt die HTML-Rohcode der Seite.
import requests
url = "https://sitecible.com"
response = requests.get(url) # requête HTTP
print(response.text) # affiche le HTML brutIm Moment hast du nur einen riesigen Text voller Tags (<html>, <div>, <p>usw.).
2. BeautifulSoup analysiert diesen rohen HTML-Code und wandelt ihn in eine organisierte Struktur. Du kannst dann auf der Seite navigieren, die Tags ausfindig machen und die Daten abrufen.
from bs4 import BeautifulSoup
soup = BeautifulSoup(response.text, "html.parser") # analyse le HTML
titre = soup.find("h1").get_text() # extrait le contenu d'un <h1>
print(titre)Warum funktioniert mein Web-Scraping-Code auf manchen Websites nicht?
Es kann vorkommen, dass dein Skript nichts abruft. Manche Websites stellen nicht ihren gesamten Inhalt direkt als HTML bereit: Sie verwenden JavaScript um die Daten dynamisch zu laden. Allerdings, BeautifulSoup kann die von JavaScript zurückgegebenen Daten nicht auswerten. In diesem Fall solltest du auf Tools wie Playwright Wo Selenium.
Welche Rolle spielt BeautifulSoup beim Web Scraping?
BeautifulSoup spielt die Rolle von’HTML-Parser. Er wandelt den Code einer Seite in ein strukturiertes Objekt um, das du leicht durchlaufen kannst. Einfach ausgedrückt ist es der Übersetzer zwischen dem rohen HTML-Code und deinem Python-Code.
Web-Scraping: BeautifulSoup oder Scrapy?
BeautifulSoup und Scrapy sind wirklich unterschiedlich, auch wenn beide dazu dienen, Web Scraping.
| BeautifulSoup | Scrapy |
|---|---|
| Eine einfache Bibliothek, die nur zum Parsen von HTML und zum Extrahieren von Daten dient. | Ein umfassendes Framework, das den gesamten Scraping-Prozess abdeckt: Abfragen, Verfolgungen von Links, Paginierung, Datenexport und Fehlerbehandlung. |
BeautifulSoup ist die perfekte Wahl für den Einstieg: Es macht das’Extraktion von HTML-Daten in Python einfach und schnell.
Wenn du den Programmcode lieber so gering wie möglich halten möchtest, bietet das Tool Bright Data bietet gebrauchsfertige Datensätze an, um den Programmieraufwand zu reduzieren.
Deutsch