Wie kann ich mit BeautifulSoup Web Scraping auf Python betreiben?

Sie möchten eintauchen in die Welt des Web Scraping aber ohne sich in komplizierten Codes zu verlieren?

Mit Python und die Bibliothek BeautifulSoup, können Sie ganz einfach Daten extrahieren und organisieren einer Website in nur wenigen Zeilen.

Voraussetzungen für das Scraping von Python mit BeautifulSoup

✅ Bevor Sie loslegen, ist es wichtig, einige Dinge zu beachten. Grundlagen der Programmierung. So können Sie besser verstehen, wie der Code funktioniert. Sie müssen kein Experte sein, aber wenn Sie Python-Skripte lesen und ausführen können, ist das sehr hilfreich.

Danach müssen Sie zunächst Folgendes tun zu machen Scraping auf Python mit BeautifulSoup :

pip install beautifulsoup4

pip install requests

Wie kann man mit Python und BeautifulSoup Web Scraping betreiben?

Folgen Sie unserem Tutorial für ein einfaches Web Scraping-Projekt.

Projekt : Den Titel einer Seite und alle darin enthaltenen Links abrufen.

Schritt 1: Seiteninhalt mit Requests abrufen

Um eine HTTP GET-Anfrage zu einer URL zu senden, müssen Sie die Bibliothek Requests.

📌 Wenn du eine HTTP-Anfrage mit Requests sendest, gibt der Server immer einen Statuscode zurück. Diese Codes geben an, ob die Anfrage erfolgreich war oder nicht.

200 : Erfolg.
301 / 302 : Umleitung.
404 : Seite nicht gefunden.
500 : interner Fehler des Servers.

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

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

# 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"))

# Ein div mit einer bestimmten id abrufen.
container = soup.find("div", id="main")

# Alle Links mit einer bestimmten Klasse abrufen.
nav_links = soup.find_all("a", class_="nav-link")

# 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"]')

Das CSS-Selektoren sind sehr leistungsstark, wenn Sie bestimmte Teile einer Seite gezielt bearbeiten möchten, ohne den gesamten HTML-Code manuell durchgehen zu müssen.

Wie extrahiert man Daten aus einer HTML-Tabelle mit BeautifulSoup?

Bisher haben wir gesehen, wie man Titel, Links oder Text aus einer Webseite extrahieren kann.

⚠ Oftmals sind die tatsächlichen Anwendungsfälle jedoch komplexer: Extraktion von strukturierten Daten wie Tabellen oder Listen, die Verwaltung der Paginierung oder auch die Behebung häufiger Fehler im Zusammenhang mit dem Scraping. Genau das werden wir gemeinsam betrachten.

Tabellen und Listen extrahieren

Webseiten präsentieren ihre Daten oft in HTML-Tabellen (<table>, <tr>, <th>, <td>) oder der Listen (

/
,
1. ). Um diese Strukturen in verwertbare Daten umzuwandeln, muss man lernen, sie Zeile für Zeile oder Element für Element zu durchlaufen.

   Wann immer Sie wollen eine HTML-Tabelle extrahierenDas Prinzip ist einfach:

   • ✅ Header abrufen (<th>), um die Spaltenüberschriften zu identifizieren.
   • ✅ Jede Zeile durchgehen (<tr>) und nach Zellen suchen (<td>), die die wahren Daten enthalten.
   • ✅ Informationen in einer Liste oder einem Wörterbuch speichern.

   Für eine HTML-Liste (

   oder
   mit
   1. ) :
      • ✅ Alle Markierungen aufspüren
      • . mit find_all.
      • ✅ Rufen Sie ihren Inhalt (Text oder Link) ab und fügen Sie ihn in eine Python-Liste ein.

      Zusammenfassend :

      Die Tags <table>, <tr>, <th>, <td> dienen dazu, ein Bild zu rekonstruieren.
      Die Tags

      /
      ,
      1. . ermöglichen es, eine HTML-Liste in eine Python-Liste umzuwandeln.

         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 ab und find_all("td") ruft die Zellen in jeder Zeile ab. Wir schleifen über 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"]
         

         Hier wird jeder

      2. . wird direkt in ein Element einer Python-Liste umgewandelt, was zu folgendem Ergebnis führt ["Apfel", "Banane", "Orange"].

         Paginierung und Links verwalten

         Häufig passen die Daten nicht auf eine einzige Seite. Sie sind über mehrere über Links von „nächste Seite“ oder ein nummerierte Paginierung (?page=1, ?page=2, ...).

         📌 In beiden Fällen müssen Sie loop (in einer Schleife durchlaufen), um alle Seiten zu holen 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)

         Kurze Erklärung :

         • Bereiten Sie die URL mit einem Platzhalter {} vor, um die Seitenzahl einzufügen.

         BASE_URL = "https://bonjour.com/articles?page={}

         • Einige Websites blockieren Anfragen ohne „Browser-Identität”. Durch Hinzufügen eines User-Agents wird vermieden, dass man für einen Bot gehalten wird.

         headers = {"User-Agent": "Mozilla/5.0"}
         requests.get(url, headers=headers) 

         • Schleife von Seite 1 bis 5.

         for page in range(1, 6):

         • Holen Sie sich das HTML der Seite.

         requests.get(url)

         • Begrenzen Sie die Wartezeit, wenn die Website nicht antwortet.

         requests.get(url, timeout=20)

         • Parsen Sie die Seite.

         BeautifulSoup(response.text, "html.parser")

         • Alle Artikeltitel abrufen.

         find_all("h2", class_="title")

         • Fügen Sie die gefundenen Artikel zu einer globalen Liste hinzu.

         all_articles.extend(Artikel)

         • Führen Sie eine Pause zwischen jeder Anfrage ein, um den Server nicht zu überlasten und eine Verbannung zu vermeiden.

         time.sleep(1.0)

         • Nach der Schleife, all_articles enthält alle Titel der 5 Seiten.

         Häufige Fehler und Herausforderungen

         ❗ Scraping bedeutet nicht immer, dass man nur auf einen Knopf drücken muss und schon ist alles fertig. Es können häufig Hindernisse auftreten, wie zum Beispiel:

         • HTTP-Fehler

         404 : Seite nicht gefunden
         403 : Zutritt verboten
         500 : serverseitiger Fehler

         Beispiel :

         response = requests.get(url)
         if response.status_code == 200:
             # Seite OK
             print("Seite erfolgreich abgerufen")
         elif response.status_code == 404:
             print("Fehler: Seite nicht gefunden")
         else:
             print("Code zurückgegeben:", response.status_code)
         

         • Websites, die das Scraping blockieren

         Einige erkennen automatische Anfragen und blockieren den Zugriff.

         • Dynamische Seiten (JavaScript)

         BeautifulSoup liest nur statisches HTML. Wenn die Seite ihr Inhalte mit JavaScriptSie werden nichts sehen.

         ✅ In diesem Fall sollten Sie Werkzeuge wie Selenium Wo Playwright.

         Übrigens: Wenn Sie effektiv scrapen wollen, ohne gesperrt zu werden oder die Website zu beschädigen, sind hier die besten Praktiken:

         • ✔ Beachten Sie den robots.txt-Datei einer Website.
         • ✔ Einsetzen von Fristen zwischen den Anfragen, um den Server nicht zu überlasten (Verwendung von time.sleep()).
         • ✔ Verwenden Sie Proxies und drehen sie.
         • ✔ Wechseln Sie regelmäßig Ihren User-Agent.

         Wie kann man mit Selenium und BeautifulSoup Web Scraping betreiben?

         

         ⚠ Kleine Erinnerung : BeautifulSoup ist ein hervorragender HTML-Parser, kann jedoch kein JavaScript einer Webseite ausführen. Hier kommt Selenium ins Spiel!

         Im Grunde genommen ist Selenium kontrolliert einen echten BrowserDas Programm führt JavaScript aus und zeigt die Seite so an, als würde ein Mensch navigieren. BeautifulSoup wird dann den HTML-Code analysieren, sobald die Seite vollständig gerendert ist. Auf diese Weise können Sie extrahieren, was Sie wollen.

         Schritt 1: Selenium und BeautifulSoup installieren

         Anstelle der Request-Bibliothek verwenden wir hier Selenium. Um es zu installieren, müssen Sie Folgendes ausführen pip.

         pip install selenium beautifulsoup4 

         Anschließend müssen Sie einen WebDriver die der Version Ihres Browsers entspricht (Beispiel: ChromeDrive für Google Chrome).

         ✅ Sie können es entweder im selben Ordner wie Ihr Python-Skript ablegen oder esZur Umgebungsvariable PATH hinzufügen Ihres Systems.

         Schritt 2: Selenium konfigurieren

         Vor allem muss importiert werden webdriver aus Selenium, um einen Browser steuern zu können.

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

         Anschließend starten wir einen Browser. Dieser öffnet die Webseite und führt das JavaScript aus (Beispiel: Chrome).

         driver = webdriver.Chrome() 

         Sie teilen dem Browser mit, welche Seite er besuchen soll.

         driver.get("https://www.exemple.com") 

         Wenn die Seite einige Elemente nur langsam anzeigt, können Sie Selenium anweisen, eine Weile zu warten.

         driver.implicitly_wait(10) 

         Schritt 3: Abrufen des Seiteninhalts

         Sobald die Seite geladen ist, erhalten Sie den Vollständiger DOM (HTML-Quellcode nach Ausführung von JS).

         html_content = driver.page_source 

         Schritt 4: HTML-Analyse mit BeautifulSoup

         Geben Sie diesen Quellcode nun an BeautifulSoup weiter, um ihn nutzen zu können:

         from bs4 import BeautifulSoup # BeautifulSoup-Objekt erstellen soup = BeautifulSoup(html_content, 'html.parser') # Beispiel: Abrufen aller Überschriften der Seite titles = soup.find_all('h2') for title in titles: print(title.get_text()) 

         👉 BeautifulSoup bietet mächtige Methoden wie find(), find_all() und CSS-Selektoren, um zielen und Elemente extrahieren des HTML-Codes.

         Schritt 5: Schließen des Browsers

         Sehr wichtig: Schließen Sie Ihren Browser nach der Ausführung immer, um Ressourcen freizugeben!

         driver.quit() 

         ✅ Und los geht's! So können Sie die Kraft von Selenium kombinieren, um eine menschliche Navigation simulieren (Klicks, Scrollen usw.) mit der Effizienz von BeautifulSoup für die Analyse des HTML-Codes.

         Häufig gestellte Fragen

         Welches ist das beste Tool für Web Scraping in Python?

         Es gibt nicht wirklich ein universelles Best-Tool, sondern vielmehr auf Ihr Projekt zugeschnittene Lösungen.

         🔥 BeautifulSoup : einfach und effektiv, um HTML zu analysieren und Inhalte schnell zu extrahieren. Es ist ideal, wenn Sie gerade erst anfangen oder kleine Projekte haben.

         🔥 Scrapy : Es handelt sich um ein umfassendes Framework, das für die Verwaltung großer Datenmengen mit erweiterten Funktionen konzipiert wurde.

         🔥 Playwright : Perfekt für komplexe, mit JavaScript generierte Websites, da es einen echten Browser simuliert und es ermöglicht, mit der Seite wie ein Mensch zu interagieren.

         Wie man mit BeautifulSoup Inhalte aus einem Tag extrahiert <div> ?

         Mit BeautifulSoup können Sie einen bestimmten Beacon mithilfe eines CSS-Selektor. So extrahieren Sie Inhalte aus einem Tag <div>Hier sind die Schritte:

         1. Seite mit Requests wiederherstellen, dann mit BeautifulSoup analysieren

         from bs4 import BeautifulSoup
         import requests
         
         url = "URL_VON_IHRER_SITE" # Ersetzen Sie durch die tatsächliche URL.
         Antwort = requests.get(url)
         html_content = reponse.text
         
         soup = BeautifulSoup(html_content, "html.parser")

         2. Verwenden Sie die Methode select() indem Sie ihm Ihren CSS-Selektor übergeben, um den Tag <div>

         Um das erste Element abzurufen, verwenden Sie soup.select_one
Um alle Elemente wiederherzustellen, verwenden Sie soup.select

         HTML-Beispiel :

         <div class="article">
           <h2>Titel des Artikels</h2>
           <p>Hier ist der Inhalt des Absatzes.</p>
         </div>

         Beispiel mit CSS :

         # Rufen Sie das erste div mit der Klasse "article" ab.
         div_article = soup.select_one("div.article")
         
         # Seinen Textinhalt anzeigen
         if div_article:
         print(div_article.get_text(strip=True))

         Hier ist der CSS-Selektor div.artikel.

         3. Elemente aus dem Inneren extrahieren <div>

         # Titel innerhalb von div abrufen
         Titel = soup.select_one("div.article h2").get_text()
         
         # Absatz innerhalb von div abrufen.
         absatz = soup.select_one("div.artikel p").get_text()
         
         print("Überschrift:", Überschrift)
         print("Absatz:", Absatz)

         Wie kann ich Requests und BeautifulSoup zusammen verwenden?

         Diese beiden Bibliotheken ergänzen sich gegenseitig.

         1. Requests ruft den Inhalt einer Webseite mit einer HTTP-Anfrage ab.

         Sie sendet eine HTTP-Anfrage an die Zielseite und lädt den rohen HTML-Code der Seite herunter.

         import requests
         
         url = "https://sitecible.com"
         response = requests.get(url) # HTTP-Anfrage.
         print(response.text) # zeigt Roh-HTML an

         Zu diesem Zeitpunkt haben Sie nur einen riesigen Text voller Tags (<html>,<div><p>usw.).

         2. BeautifulSoup analysiert diesen HTML-Inhalt, um das herauszufiltern, was Sie interessiert.

         Es nimmt den rohen HTML-Code und wandelt ihn in eine organisierte Struktur um. Dadurch können Sie leicht innerhalb des HTML-Codes navigieren: Daten suchen, extrahieren und abrufen.

         from bs4 import BeautifulSoup
         
         soup = BeautifulSoup(response.text, "html.parser") # analysiert HTML.
         titel = soup.find("h1").get_text() # extrahiert den Inhalt eines <h1>
         print(titel)

         Warum funktioniert mein Web-Scraping-Code auf manchen Websites nicht?

         Es kommt vor, dass Ihr Skript nichts abrufen kann, da einige Websites nicht alle Inhalte direkt in HTML bereitstellen.

         Diese Websites verwenden JavaScript, um Daten dynamisch zu laden. BeautifulSoup erlaubt jedoch keinevon JavaScript gerenderte Daten analysieren.

         In diesem Fall sollten Sie sich an Tools wie Playwright Wo Selenium.

         Welche Rolle spielt BeautifulSoup beim Web Scraping?

         BeautifulSoup spielt die Rolle vonHTML-Parser.

         Es nimmt den Quellcode einer Seite als reinen Text und wandelt ihn in ein strukturiertes Objekt um, das Sie leicht durchsuchen können.

         Ohne diese Bibliothek sehen Sie einen riesigen, unleserlichen Textblock. Einfach ausgedrückt: BeautifulSoup ist der Übersetzer zwischen dem Roh-HTML und Ihr Python-Code.

         Web Scraping: BeautifulSoup vs. Scrapy?

         BeautifulSoup und Scrapy sind wirklich unterschiedlich, auch wenn beide zum Web Scraping dienen.

         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 steuert (Abfragen, Verfolgung von Links, Paginierung, Datenexport, Fehlerbehandlung).

         Zusammenfassend lässt sich sagen, dass BeautifulSoup dieExtraktion von HTML-Daten in Python. Diese Bibliothek ist perfekt für den Anfang, da sie das Scrapbooking einfach und schnell macht.

         Ansonsten, wenn Sie nicht wollen nicht codieren, das umfassende Tool Bright Data eignet sich auch hervorragend zum Web Scraping.

         👉 Jetzt sag uns als Kommentar, was du erfolgreich gescrapt hast!