---
title: "HTML Web-Scraping-Tutorial"
slug: html-web-scraping
date: 2026-02-22T07:24:11+00:00
modified: 2026-08-26T19:37:16+00:00
permalink: https://brightdata.de/blog/wie/html-web-scraping
type: blog
---
[ Blog ](https://brightdata.de/blog "Blog") / [How Tos](https://brightdata.de/blog/wie)
[How Tos](https://brightdata.de/blog/wie)
# HTML Web-Scraping-Tutorial
Erfahren Sie, wie Sie HTML-Web-Scraping meistern, um effizient Daten von Websites zu sammeln – ideal zur Verbesserung Ihrer Projekte und Strategien.
16 min lesen
[  ](https://brightdata.com/blog/authors/naman-bansal)
[Naman Bansal
](https://brightdata.com/blog/authors/naman-bansal)
Wenn Sie sich für Web-Scraping interessieren, ist das Verständnis von HTML entscheidend, da jede Website damit aufgebaut ist. Web-Scraping kann in allen möglichen Szenarien eingesetzt werden und hilft dabei, Daten von Websites ohne APIs zu sammeln, Produktpreise zu überwachen, Lead-Listen aufzubauen, akademische Forschung zu betreiben und vieles mehr.
In diesem Artikel lernen Sie die Grundlagen von HTML und wie Sie Daten mit Python extrahieren, parsen und verarbeiten können.
Interessiert an einem ausführlichen Python-Web-Scraping-Leitfaden? [Klicken Sie hier](/blog/how-tos/web-scraping-with-python).
## Wie man Websites scrapt und HTML extrahiert
Bevor Sie mit diesem Tutorial beginnen, nehmen Sie sich einen Moment Zeit, um die wesentlichen Komponenten von HTML zu überprüfen.
### Einführung in HTML
HTML ist eine Sammlung von Tags, die einem Browser die Struktur und die Elemente einer Website mitteilen. Zum Beispiel teilt `
Text
` einem Browser mit, dass der auf den Tag folgende Text eine Überschrift ist, und ` link ` identifiziert einen Hyperlink.
Ein HTML-Attribut liefert zusätzliche Informationen über einen Tag. Zum Beispiel gibt Ihnen das `href`-Attribut für den ``-Tag Informationen über die URL der Seite, auf die das Attribut verweist.
[Klassen und IDs](https://www.scaler.com/topics/html/class-and-id-in-html/) sind wichtige Attribute zur genauen Identifizierung von Elementen auf einer Seite. Klassen gruppieren ähnliche Elemente, um sie mit CSS einheitlich zu gestalten oder mit JavaScript gleichmäßig zu manipulieren. Klassen werden mit `.class-name` angesprochen.
Auf der W3Schools-Website sehen Klassengruppen so aus:
```none
London
London is the capital of England.
Paris
Paris is the capital of France.
Tokyo
Tokyo is the capital of Japan.
```
Sie können sehen, wie jeder Titel- und Stadtblock mit einem `div` umschlossen ist, das dieselbe `city`-Klasse hat.
IDs hingegen sind für jedes Element eindeutig (d. h. zwei Elemente können nicht dieselbe ID haben). Zum Beispiel haben die folgenden H1s eindeutige IDs und können individuell gestaltet/manipuliert werden:
```none
Hello World!
Lorem Ipsum Dolor
```
Die Syntax zum Ansprechen von Elementen mit IDs lautet `#id-name`.
Jetzt, da Sie die Grundlagen von HTML kennen, können wir mit dem Web-Scraping beginnen.
## Richten Sie Ihre Scraping-Umgebung ein
Dieses Tutorial verwendet Python, da es viele HTML-Scraping-Bibliotheken bietet und die Sprache leicht zu erlernen ist. Um zu prüfen, ob Python auf Ihrem Computer installiert ist, führen Sie den folgenden Befehl in PowerShell (Windows) oder Ihrem Terminal (macOS) aus:
```none
python3
```
Wenn Python installiert ist, sehen Sie Ihre Versionsnummer; andernfalls erhalten Sie eine Fehlermeldung. Gehen Sie voran und [installieren Sie Python](https://www.python.org/downloads/), falls Sie es noch nicht haben.
Erstellen Sie als Nächstes einen Ordner namens `WebScraper` und erstellen Sie darin eine Datei namens `scraper.py`. Öffnen Sie diese dann in Ihrer bevorzugten integrierten Entwicklungsumgebung (IDE). [Visual Studio Code](https://code.visualstudio.com/) wird hier verwendet:
Eine IDE ist eine vielseitige Anwendung, die Programmierern ermöglicht, Code zu schreiben, zu debuggen, Programme zu testen, Automatisierungen zu erstellen und vieles mehr. Sie verwenden sie hier, um Ihren HTML-Scraper zu programmieren.
Als Nächstes müssen Sie Ihre globale Python-Installation von Ihrem Scraping-Projekt trennen, indem Sie eine virtuelle Umgebung erstellen. Dies hilft, Abhängigkeitskonflikte zu vermeiden und die gesamte Anwendung organisiert zu halten.
Installieren Sie dazu die `virtualenv`-Bibliothek mit dem folgenden Befehl:
```none
pip3 install virtualenv
```
Navigieren Sie in Ihren Projektordner:
```none
cd WebScraper
```
Erstellen Sie dann eine virtuelle Umgebung:
```none
python -m venv
```
Dieser Befehl erstellt einen Ordner für alle Pakete und Skripte in Ihrem Projektordner:
Jetzt müssen Sie die virtuelle Umgebung mit einem der folgenden Befehle aktivieren (je nach Ihrer Plattform):
```none
source /bin/activate #In MacOS and Linux
/Scripts/activate.bat #In CMD
/Scripts/Activate.ps1 #In Powershell
```
Nach erfolgreicher Aktivierung sehen Sie den Namen Ihrer virtuellen Umgebung auf der linken Seite des Bildschirms:
Nun, da Ihre virtuelle Umgebung aktiviert ist, müssen Sie eine Web-Scraping-Bibliothek installieren. Es gibt zahlreiche Optionen, darunter [Playwright](https://playwright.dev/), [Selenium](https://www.selenium.dev/), [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) und [Scrapy](https://scrapy.org/). Hier verwenden Sie [Playwright](https://playwright.dev/python/docs/intro), da es einfach zu bedienen ist, mehrere Browser unterstützt, dynamische Inhalte verarbeiten kann und einen Headless-Modus bietet (Scraping ohne grafische Benutzeroberfläche (GUI)).
Führen Sie `pip install pytest-playwright` aus, um Playwright zu installieren; installieren Sie dann die erforderlichen Browser mit `playwright install`.
Nach der Installation von Playwright sind Sie bereit, mit dem Web-Scraping zu beginnen.
## HTML von einer Website extrahieren
Der erste Schritt bei jedem Web-Scraping-Projekt ist die Identifizierung der Website, die Sie scrapen möchten. Hier verwenden Sie [diese Testseite](https://webscraper.io/test-sites/e-commerce/static).
Als Nächstes müssen Sie die Informationen identifizieren, die Sie von der Seite scrapen möchten. In diesem Fall handelt es sich um den vollständigen HTML-Inhalt der Seite.
Sobald Sie die zu scrapenden Informationen identifiziert haben, können Sie mit der Programmierung des Scrapers beginnen. In Python ist der erste Schritt das [Importieren der erforderlichen Bibliotheken für Playwright](https://playwright.dev/python/docs/library). Playwright ermöglicht den Import von zwei API-Typen: [sync und async](https://stackoverflow.com/questions/65439214/what-are-the-differences-between-python-playwright-sync-vs-async-apis). Die async-Bibliothek wird nur beim Schreiben von asynchronem Code verwendet, daher importieren Sie die sync-Bibliothek mit folgendem Befehl:
```none
from playwright.sync_api import sync_playwright
```
Nach dem Import der sync-Bibliothek müssen Sie eine Python-Funktion mit folgendem Code-Snippet deklarieren:
```none
def main():
#Rest of the code will be inside this function
```
Wie Sie aus dem vorangehenden Hinweis ersehen können, schreiben Sie Ihren Web-Scraping-Code innerhalb dieser Funktion.
Um Informationen von einer Website zu erhalten, würden Sie normalerweise einen Webbrowser öffnen, einen neuen Tab erstellen und diese Website besuchen. Um die Seite zu scrapen, müssen Sie diese Aktionen in Code übersetzen, wofür Sie Playwright verwenden. Die [Dokumentation](https://playwright.dev/python/docs/library) zeigt, dass Sie die zuvor importierte `sync_api` aufrufen und einen Browser mit diesem Snippet öffnen können:
```none
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
```
Durch das Hinzufügen von `headless=False` in den Klammern können Sie den Inhalt der Website sehen.
Nachdem Sie Ihren Browser geöffnet haben, öffnen Sie einen neuen Tab und besuchen Sie die Ziel-URL:
```none
page = browser.new_page()
try:
page.goto("https://webscraper.io/test-sites/e-commerce/static")
except:
print("Error")
```
> **Hinweis:** Die vorangehenden Zeilen müssen unter den Zeilen hinzugefügt werden, die den Browser gestartet haben. Dieser gesamte Code befindet sich innerhalb der Hauptfunktion und in einer Datei.
Dieses Code-Snippet umschließt die `goto()`-Funktion innerhalb eines [try-except-Blocks](https://www.w3schools.com/python/python_try_except.asp) für eine bessere Fehlerbehandlung.
Wenn Sie die URL einer Website in die Suchleiste eingeben, müssen Sie warten, bis sie geladen ist. Um das im Code nachzuahmen, können Sie Folgendes verwenden:
```none
page.wait_for_timeout(7000) #millisecond value in brackets
```
> **Hinweis:** Diese vorangehenden Zeilen müssen unter den Zeilen davor hinzugefügt werden.
Schließlich ist es an der Zeit, den gesamten HTML-Inhalt der Seite mit dieser Codezeile zu extrahieren:
```none
print(page.content())
```
Der vollständige Code zum Extrahieren des HTML einer Seite sieht so aus:
```none
from playwright.sync_api import sync_playwright
def main():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
try:
page.goto("https://webscraper.io/test-sites/e-commerce/static")
except:
print("Error")
page.wait_for_timeout(7000)
print(page.content())
main()
```
In Visual Studio Code sieht das extrahierte HTML so aus:
## HTML mit spezifischen Attributen extrahieren
Zuvor haben Sie alle Elemente der Web-Scraper-Webseite extrahiert; Web-Scraping ist jedoch nur nützlich, wenn Sie sich darauf beschränken, nur die benötigten Informationen zu scrapen. In diesem Abschnitt extrahieren Sie nur die Titel aller Laptops auf der ersten Seite der Website:
Um bestimmte Elemente zu extrahieren, müssen Sie die Struktur der Zielwebsite verstehen. Sie können dies tun, indem Sie mit der rechten Maustaste klicken und die Option **Untersuchen** auswählen:
Alternativ können Sie diese Tastaturkürzel verwenden:
- Für macOS verwenden Sie **Cmd + Option + I**
- Für Windows verwenden Sie **Control + Shift + C**
Hier ist die Struktur der Zielseite:
Sie können den Code für ein bestimmtes Element auf einer Seite mit dem Auswahlwerkzeug oben links im **Untersuchen**-Fenster anzeigen:
Wählen Sie einen der Laptop-Titel in Ihrem **Untersuchen**-Fenster aus:
Sie können sehen, dass der Titel innerhalb eines ``-Tags liegt, der von einem `h4`-Tag umschlossen ist, und der Link hat eine Klasse `title`. Das bedeutet, Sie suchen nach ``-Tags (URLs) innerhalb von `
`-Tag) ist und den inneren Text `2` hat:
Das bedeutet, Sie können den `get_by_role()`-Selektor verwenden, um ein Listenelement zu finden, und einen `get_by_text()`-Selektor, um ein Element mit `2` als Text zu finden.
So programmieren Sie es in Ihrer Datei:
```none
page.get_by_role("listitem").get_by_text("2", exact=True)
```
Dies findet ein Element, das zwei Bedingungen erfüllt: Erstens muss es ein Listenelement sein, und zweitens sollte es `2` als Text haben.
`exact=True` ist ein Funktionsargument, um das Element mit dem angegebenen Text zu finden.
Um die Schaltfläche zu klicken, ändern Sie den vorherigen Code so, dass er so aussieht:
```none
page.get_by_role("listitem").get_by_text("2", exact=True).click()
```
In diesem Code klickt die `click()`-Funktion auf das angegebene Element.
Warten Sie, bis die Seite geladen ist, und extrahieren Sie alle Titel erneut:
```none
page.wait_for_timeout(5000)
titles = page.get_by_role("heading").all()
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
print(laptop[0])
```
Ihr vollständiger Codeblock sollte so aussehen:
```none
from playwright.sync_api import sync_playwright
def main():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
try:
page.goto("https://webscraper.io/test-sites/e-commerce/static/computers/laptops")
except:
print("Error")
page.wait_for_timeout(7000)
titles = page.get_by_role("heading").all()
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
print(laptop[0])
page.get_by_role("listitem").get_by_text("2", exact=True).click()
page.wait_for_timeout(5000)
titles = page.get_by_role("heading").all()
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
print(laptop[0])
main()
```
## HTML extrahieren und in eine CSV-Datei schreiben
Wenn Sie die gescrapten Daten nicht speichern und analysieren, sind sie nutzlos. In diesem Abschnitt erstellen Sie ein erweitertes Programm, das Benutzereingaben für die Anzahl der zu scrapenden Laptop-Seiten entgegennimmt, die Titel extrahiert und sie in einer CSV-Datei in Ihrem Projektordner speichert.
Für dieses Programm benötigen Sie eine vorinstallierte CSV-Bibliothek, die mit folgendem Befehl importiert werden kann:
```none
import csv
```
Nachdem Sie die CSV-Bibliothek installiert haben, müssen Sie herausfinden, wie Sie je nach Benutzereingabe eine variable Anzahl von Seiten besuchen.
Wenn Sie sich die URL-Struktur der Website ansehen, werden Sie feststellen, dass jede Seite mit Laptops durch einen URL-Parameter angegeben wird. Zum Beispiel lautet die URL der zweiten Seite im Laptop-Verzeichnis https://webscraper.io/test-sites/e-commerce/static/computers/laptops?page=2.
Sie können verschiedene Seiten besuchen, indem Sie den URL-Parameter `?page=2` mit verschiedenen numerischen Werten ändern. Das bedeutet, Sie müssen den Benutzer auffordern, die Anzahl der zu scrapenden Seiten mit folgendem Befehl einzugeben:
```none
pages = int(input("enter the number of pages to scrape: "))
```
Um jede Seite von 1 bis zur vom Benutzer eingegebenen Seitenanzahl zu besuchen, verwenden Sie eine `for`-Schleife wie folgt:
```none
for i in range(1, pages+1):
```
Innerhalb dieser `range`-Funktion verwenden Sie `1` und `pages+1` als Funktionsargumente, um die Werte darzustellen, bei denen die Schleife beginnt und endet. Das zweite Funktionsargument ist von der Schleife ausgeschlossen. Wenn die range-Funktion beispielsweise `range(1,5)` ist, würde das Programm nur von 1 bis 4 schleifen.
Als Nächstes müssen Sie jede Seite besuchen, indem Sie den `i`-Wert als URL-Parameter in der Iteration eingeben. Sie können Variablen mit [Python f-Strings](https://www.geeksforgeeks.org/formatted-string-literals-f-strings-python/) zu einem String hinzufügen.
Bei der Ausgabe eines Strings stellen Sie den Anführungszeichen ein `f` voran, um anzuzeigen, dass es sich um einen f-String handelt. Innerhalb der Anführungszeichen können Sie geschweifte Klammern verwenden, um Variablen anzugeben.
Hier ist ein Beispiel, wie Sie f-Strings verwenden können, um Variablen zusammen mit Strings auszugeben:
```none
print(f"The value of the variable is {variable_name_goes_here}")
```
Zurück zum Scraper können Sie f-Strings nutzen, indem Sie diesen Codeblock in die Datei schreiben:
```none
try:
page.goto(f"https://webscraper.io/test-sites/e-commerce/static/computers/laptops?page={i}")
except:
print("Error")
```
Warten Sie mit einer Timeout-Funktion auf das Laden der Seite und extrahieren Sie die Titel mit Folgendem:
```none
page.wait_for_timeout(7000)
titles = page.get_by_role("heading").all()
```
Sobald Sie alle Titelelemente haben, müssen Sie Ihre CSV-Datei öffnen, jeden Titel durchlaufen, den erforderlichen Text extrahieren und ihn in Ihre Datei schreiben.
Um eine CSV-Datei zu öffnen, verwenden Sie folgende Syntax:
```none
with open("laptops.csv", "a") as csvfile:
```
Hier öffnen Sie die `laptops.csv`-Datei im Anhänge-Modus (`a`). Sie verwenden den Anhänge-Modus, weil Sie nicht jedes Mal alte Daten verlieren möchten, wenn die Datei geöffnet wird. Wenn die Datei nicht existiert, erstellt die Bibliothek eine im Projektordner. [CSV bietet mehrere Modi](https://www.learnbyexample.org/reading-and-writing-csv-files-in-python/) zum Öffnen einer Datei, darunter:
- **r** ist die Standardoption, wenn nichts angegeben wird. Sie öffnet die Datei nur zum Lesen.
- **w** öffnet eine Datei nur zum Schreiben. Jedes Mal, wenn eine Datei geöffnet wird, werden die vorherigen Daten überschrieben.
- **a** öffnet eine Datei zum Anhängen von Daten. Vorherige Daten werden nicht überschrieben.
- **r+** öffnet eine Datei sowohl zum Lesen als auch zum Schreiben.
- **x** erstellt eine neue Datei.
Unter dem vorherigen Code müssen Sie [ein `writer`-Objekt deklarieren](https://docs.python.org/3/library/csv.html#csv.writer), das Ihnen die Manipulation der CSV-Datei ermöglicht:
```none
writer = csv.writer(csvfile)
```
Anschließend durchlaufen Sie jedes Titelelement und extrahieren den Text mit Folgendem:
```none
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
```
Dies gibt Ihnen mehrere Arrays, von denen jedes den Titel einzelner Laptops enthält. Um leere Arrays abzulehnen, schreiben Sie folgenden bedingten Code in die CSV-Datei:
```none
if len(laptop) == 1:
writer.writerow([laptop[0]])
```
Die `writerow`-Funktion ermöglicht es Ihnen, neue Zeilen in eine CSV-Datei zu schreiben.
Hier ist der gesamte Code für das Programm:
```none
from playwright.sync_api import sync_playwright
import csv
def main():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
pages = int(input("enter the number of pages to scrape: "))
for i in range(1, pages+1):
try:
page.goto(f"https://webscraper.io/test-sites/e-commerce/static/computers/laptops?page={i}")
except:
print("Error")
page.wait_for_timeout(7000)
titles = page.get_by_role("heading").all()
with open("laptops.csv", "a") as csvfile:
writer = csv.writer(csvfile)
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
writer.writerow([laptop[0]])
browser.close()
main()
```
Nach dem Ausführen dieses Codes sollte Ihre CSV-Datei so aussehen:
## Fazit
In diesem Artikel haben Sie gelernt, wie Sie HTML mit Python extrahieren, parsen und speichern.
Obwohl dieses Tutorial relativ unkompliziert war, würden Sie in einem realen Szenario beim Scraping wahrscheinlich auf verschiedene Hindernisse stoßen, darunter CAPTCHAs, Ratenlimits, Änderungen des Website-Layouts oder regulatorische Anforderungen. Zum Glück kann [Bright Data](/) helfen. Bright Data bietet Tools wie [erweiterte Residential-Proxys](/proxy-types/residential-proxies) zur Verbesserung Ihres Scrapings, eine [Web Scraper IDE](/products/web-scraper) zum Erstellen von Scrapern in großem Maßstab und einen [Web Unlocker](/products/web-unlocker) zum Entsperren öffentlicher Websites, einschließlich [CAPTCHA-Lösung](/products/web-unlocker/captcha-solver). Diese Tools helfen Ihnen, genaue Daten in großem Maßstab zu sammeln und Hindernisse zu überwinden. Darüber hinaus gewährleistet Bright Datas Engagement für ethisches Scraping, dass Sie die Nutzungsbedingungen der Website und gesetzliche Vorschriften einhalten.
Mit Bright Datas funktionsreicher Scraping-Infrastruktur können Sie sich auf die Extraktion der wertvollen Daten konzentrieren, die Sie benötigen, und die Komplexität des Web-Scrapings hinter sich lassen. Starten Sie noch heute Ihren kostenlosen Test!
Vertrieb kontaktierenGratis testen
Inhaltsverzeichnis
Dedicated Scraper APIs & No-Code Scrapers
Over 1000 scrapers for all popular domains. Simplify your web scraping.
[See pricing](/pricing/web-scraper "See pricing")
Just want data? Skip scraping.
Hundreds of ready-to-use datasets from all popular domains.
[See pricing](/pricing/datasets "See pricing")
[ ](https://news.ycombinator.com/submitlink?t=HTML+Web-Scraping-Tutorial&u=https://brightdata.de/blog/wie/html-web-scraping) [ ](https://www.linkedin.com/shareArticle?mini=true&title=HTML+Web-Scraping-Tutorial&url=https://brightdata.de/blog/wie/html-web-scraping) [ ](http://www.reddit.com/submit?title=HTML+Web-Scraping-Tutorial&url=https://brightdata.de/blog/wie/html-web-scraping)
## Das könnte Sie auch interessieren
[  ](https://brightdata.de/blog/web-data-de/best-html-parsers "Die besten HTML-Parsing-Bibliotheken für Web-Scraping")
[Web Data
Antonello Zanini
Technical Writer
### Die besten HTML-Parsing-Bibliotheken für Web-Scraping
Entdecken Sie die besten HTML-Parser für Web-Scraping und Datenextraktion, darunter httpx, AIOHTTP und urllib.
24-Mar-2024
7 min lesen
](https://brightdata.de/blog/web-data-de/best-html-parsers)
[  ](https://brightdata.de/blog/web-data-de/cheerio-vs-puppeteer "Cheerio vs. Puppeteer für Web Scraping")
[Web Data
Gints Dreimanis
### Cheerio vs. Puppeteer für Web Scraping
Ein Blick auf die Unterschiede zwischen Puppeteer und Cheerio, indem wir einen Web Scraper mit beiden erstellen.
09-Feb-2023
9 min lesen
](https://brightdata.de/blog/web-data-de/cheerio-vs-puppeteer)
[  ](https://brightdata.de/blog/proxys-101/how-to-bypass-an-ip-ban "So umgehst du eine IP-Sperre: 7 bewährte Methoden (Leitfaden 2026)")
[Proxy 101
Aviv Besinsky
### So umgehst du eine IP-Sperre: 7 bewährte Methoden (Leitfaden 2026)
7 bewährte Methoden zur Umgehung von IP-Sperren kennenlernen – von Residential-Proxys (95-99% Erfolg) bis hin zu VPNs und IP-Rotation.
11-Aug-2022
22 min lesen
](https://brightdata.de/blog/proxys-101/how-to-bypass-an-ip-ban)