` erstellt das `` -Tag einzelne Zellen innerhalb dieser Zeile, die die in jeder Zelle angezeigten Daten enthalten.
> **Hinweis:** Bevor Sie mit dem Scraping beginnen, sollten Sie unbedingt die Datenschutzrichtlinien und Nutzungsbedingungen der Website lesen und einhalten, um sicherzustellen, dass Sie alle Einschränkungen hinsichtlich der Datennutzung und des automatisierten Zugriffs beachten.
## Senden Sie eine HTTP-Anfrage, um auf die Webseite zuzugreifen
Um eine HTTP-Anfrage zu senden und auf die Webseite zuzugreifen, erstellen Sie eine Python-Datei (*z. B.* `html_table_scraper.py`) und importieren Sie die Pakete `requests`, `BeautifulSoup` und `pandas`:
```none
# Pakete importieren
import requests
from bs4 import BeautifulSoup
import pandas as pd
```
Definieren Sie dann die URL der Webseite, die Sie scrapen möchten, und senden Sie eine GET-Anfrage an diese Webseite mit `https://www.worldometers.info/world-population/population-by-country/`:
```none
# Anfrage an die Website senden, um den Seiteninhalt abzurufen
url = 'https://www.worldometers.info/world-population/population-by-country/'
```
Um zu überprüfen, ob die Antwort erfolgreich ist oder nicht, senden Sie eine Anfrage mit der Methode `get()` aus Requests:
```none
# Den Inhalt der URL abrufen
response = requests.get(url)
# Den Status der Antwort überprüfen.
if response.status_code == 200:
print("Anfrage war erfolgreich!")
else:
print(f"Fehler: {response.status_code} - {response.text}")
```
Dieser Code sendet eine GET-Anfrage an eine bestimmte URL und überprüft dann den Status der Antwort. Eine `200-` Antwort zeigt an, dass die Anfrage erfolgreich war.
Verwenden Sie den folgenden Befehl, um das Python-Skript in Ihrem Terminal auszuführen:
```none
python html_table_scraper.py
```
Die Ausgabe sollte wie folgt aussehen:
```none
Anfrage war erfolgreich!
```
Da die GET-Anfrage erfolgreich war, verfügen Sie nun über den HTML-Inhalt der gesamten Webseite, einschließlich der HTML-Tabelle.
## Parsen Sie den HTML-Code mit Beautiful Soup
Beautiful Soup kann schlecht formatierte oder fehlerhafte HTML-Inhalte verarbeiten, was beim Web-Scraping häufig vorkommt. Hier verwenden Sie das Beautiful Soup-Paket, um Folgendes zu tun:
- Parsen Sie den HTML-Inhalt der Webseite, um die Tabelle mit den Bevölkerungsdaten zu finden.
- Sammeln Sie die Tabellenüberschriften.
- Sammeln Sie alle Daten, die in den Zeilen der Tabelle dargestellt sind.
Um die gesammelten Inhalte zu parsen, erstellen Sie ein Beautiful Soup-Objekt:
```none
# Parsen Sie den HTML-Inhalt mit BeautifulSoup.
soup = BeautifulSoup(response.content, 'html.parser')
```
Suchen Sie als Nächstes das Tabellenelement im HTML-Code mit dem `ID` -Attribut ` „example2`”. Diese Tabelle enthält die Bevölkerungszahlen der Länder im Jahr 2024:
```none
# Die Tabelle mit den Bevölkerungsdaten suchen
table = soup.find('table', attrs={'id': 'example2'})
```
### Tabellenkopfzeilen erfassen
Die Tabelle hat eine Kopfzeile, die sich in den HTML-Tags `` und `` befindet. Verwenden Sie die Methode `find()` aus dem Beautiful Soup-Paket, um die Daten im Tag `` zu extrahieren, und die Methode `find_all()`, um alle Kopfzeilen zu sammeln:
```none
# Sammeln Sie die Überschriften aus der Tabelle.
headers = []
# Suchen Sie die Überschriftenzeile innerhalb des Tags .
header_row = table.find('thead').find_all('th')
for th in header_row:
# Fügen Sie den Überschriftentext zur Liste „headers” hinzu.
headers.append(th.text.strip())
```
Dieser Code erstellt eine leere Python-Liste namens `„headers“`, sucht den HTML-Tag ``, um alle Kopfzeilen innerhalb der HTML-Tags `| ` zu finden, und hängt dann jede gesammelte Kopfzeile an die Liste `„headers“` an.
### Tabellenzeilendaten sammeln
Um die Daten in jeder Zeile zu erfassen, erstellen Sie eine leere Python-Liste namens `„data“`, um die gescrapten Daten zu speichern:
```none
# Initialisieren Sie eine leere Liste zum Speichern unserer Daten
data = []
```
Extrahieren Sie dann die Daten in jeder Zeile der Tabelle mit der Methode `„find_all()“` und fügen Sie sie an die Python-Liste an:
```none
# Durchlaufen Sie jede Zeile in der Tabelle (überspringen Sie die Kopfzeile)
for tr in table.find_all('tr')[1:]:
# Erstellen Sie eine Liste mit den Daten der aktuellen Zeile
row = []
# Alle Datenzellen in der aktuellen Zeile suchen
for td in tr.find_all('td'):
# Den Textinhalt der Zelle abrufen und zusätzliche Leerzeichen entfernen
cell_data = td.text.strip()
# Die bereinigten Zellendaten zur Zeilenliste hinzufügen
row.append(cell_data)
# Nachdem alle Zellen für diese Zeile abgerufen wurden, die Zeile zur Datenliste hinzufügen
data.append(row)
# Die gesammelten Daten zur einfacheren Verarbeitung in einen Pandas-DataFrame konvertieren
df = pd.DataFrame(data, columns=headers)
# Den DataFrame ausgeben, um die Anzahl der Zeilen und Spalten anzuzeigen
print(df.shape)
```
Dieser Code durchläuft alle ` | ` -HTML-Tags, die in der `Tabelle` gefunden werden, beginnend mit der zweiten Zeile (die Kopfzeile wird übersprungen). Für jede Zeile (` `) wird eine leere `Listenzeile` erstellt, um die Daten aus den Zellen dieser Zeile zu speichern. Innerhalb der Zeile findet der Code alle `| ` -HTML-Tags mit der Methode `find_all()`, die einzelne Datenzellen in der Zeile darstellen.
Für jedes HTML-Tag ` | ` extrahiert der Code den Textinhalt mit dem ` Attribut .text`und wendet die Methode `.strip()` an, um alle führenden oder nachfolgenden Leerzeichen aus dem Text zu entfernen. Die bereinigten Zellendaten werden an die `Zeilenliste` angehängt. Nach der Verarbeitung aller Zellen in der aktuellen Zeile wird die gesamte Zeile an die `Datenliste` angehängt. Schließlich konvertieren Sie die gesammelten Daten in ein Pandas-DataFrame mit den durch die `Headers-Liste` definierten Spaltennamen und zeigen dann die Form der Daten an.
Das vollständige Python-Skript sollte wie folgt aussehen:
```none
# Pakete importieren
import requests
from bs4 import BeautifulSoup
import pandas as pd
# Eine Anfrage an die Website senden, um den Seiteninhalt abzurufen
url = 'https://www.worldometers.info/world-population/population-by-country/'
# Den Inhalt der URL abrufen
response = requests.get(url)
# Überprüfen, ob die Anfrage erfolgreich war
if response.status_code == 200:
# HTML-Inhalt mit Beautiful Soup analysieren
soup = BeautifulSoup(response.content, 'html.parser')
# Tabelle mit Bevölkerungsdaten anhand ihrer ID suchen
table = soup.find('table', attrs={'id': 'example2'})
# Sammeln Sie die Kopfzeilen aus der Tabelle
headers = []
# Suchen Sie die Kopfzeilenreihe innerhalb des HTML-Tags
header_row = table.find('thead').find_all('th')
for th in header_row:
# Fügen Sie den Kopfzeilentext zur Liste der Kopfzeilen hinzu
headers.append(th.text.strip())
# Leere Liste initialisieren, um unsere Daten zu speichern
data = []
# Jede Zeile in der Tabelle durchlaufen (Kopfzeile überspringen)
for tr in table.find_all('tr')[1:]:
# Liste mit den Daten der aktuellen Zeile erstellen
row = []
# Alle Datenzellen in der aktuellen Zeile suchen
for td in tr.find_all('td'):
# Textinhalt der Zelle abrufen und zusätzliche Leerzeichen entfernen
cell_data = td.text.strip()
# Bereinigte Zellendaten zur Zeilenliste hinzufügen
row.append(cell_data)
# Nachdem alle Zellen für diese Zeile abgerufen wurden, die Zeile zu unserer Datenliste hinzufügen
data.append(row)
# Konvertieren Sie die gesammelten Daten in ein Pandas-DataFrame, um die Handhabung zu vereinfachen.
df = pd.DataFrame(data, columns=headers)
# Drucken Sie das DataFrame aus, um die gesammelten Daten anzuzeigen.
print(df.shape)
else:
print(f"Fehler: {response.status_code} - {response.text}")
```
Verwenden Sie den folgenden Befehl, um das Python-Skript in Ihrem Terminal auszuführen:
```none
python html_table_scraper.py
```
Ihre Ausgabe sollte wie folgt aussehen:
```none
(234,12)
```
Zu diesem Zeitpunkt haben Sie erfolgreich 234 Zeilen und 12 Spalten aus der HTML-Tabelle extrahiert.
Verwenden Sie als Nächstes die Methode `head()` aus pandas und `print()`, um die ersten zehn Zeilen der extrahierten Daten anzuzeigen:
```none
print(df.head(10))
```
## Daten bereinigen und strukturieren
Beim Scraping von Daten aus einer HTML-Tabelle ist es wichtig, die Daten zu bereinigen, um Konsistenz, Genauigkeit und eine ordnungsgemäße Verwendbarkeit für die Analyse sicherzustellen. Aus einer HTML-Tabelle extrahierte Rohdaten können verschiedene Probleme enthalten, wie fehlende Werte, Formatierungsprobleme, unerwünschte Zeichen oder falsche Datentypen. Diese Probleme können zu ungenauen Analysen und unzuverlässigen Ergebnissen führen. Eine ordnungsgemäße Bereinigung hilft bei der Standardisierung des Datensatzes und stellt sicher, dass er mit der für die Analyse vorgesehenen Struktur übereinstimmt.
In diesem Abschnitt werden die folgenden Datenbereinigungsaufgaben durchgeführt:
- Umbenennen von Spaltennamen
- Ersetzen fehlender Werte in den Zeilendaten
- Entfernen von Kommas und Konvertieren von Datentypen in das richtige Format
- Entfernen des Prozentzeichens (%) und Konvertieren der Datentypen in das richtige Format
- Ändern der Datentypen für numerische Spalten
### Spaltennamen umbenennen
pandas verfügt über eine Methode namens `rename()`, mit der Sie den Namen einer bestimmten Spalte nach Belieben ändern können. Diese Methode ist nützlich, wenn Spaltennamen nicht aussagekräftig sind oder wenn Sie die Spaltennamen benutzerfreundlicher gestalten möchten.
Um eine bestimmte Spalte umzubenennen, übergeben Sie ein Wörterbuch an den Parameter `columns`, wobei die Schlüssel die aktuellen Spaltennamen und die Werte die neuen Namen sind, die Sie zuweisen möchten. Wenden Sie diese Methode an, um die folgenden Spaltennamen zu ändern:
- `#`zu`Rang`
- `Jährliche Veränderung`in`Jährliche Veränderung %`
- `Weltmarktanteil`in`Weltmarktanteil %`
```none
# Spalten umbenennen
df.rename(columns={'#': 'Rank'}, inplace=True)
df.rename(columns={'Yearly Change': 'Yearly Change %'}, inplace=True)
df.rename(columns={'World Share': 'World Share %'}, inplace=True)
# Die ersten 5 Zeilen anzeigen
print(df.head())
```
Ihre Spalten sollten nun wie folgt aussehen:
### Fehlende Werte ersetzen
Fehlende Werte in den Daten können Berechnungen wie Durchschnittswerte oder Summen beeinflussen und zu ungenauen Ergebnissen und falschen Erkenntnissen führen. Sie müssen diese Werte entfernen, ersetzen oder durch bestimmte Werte ersetzen, bevor Sie Berechnungen oder Analysen mit dem Datensatz durchführen.
Die Spalte `„Urban Pop %”` enthält derzeit fehlende Werte `,` die als `N.A.` gekennzeichnet sind `.` Ersetzen Sie `N.A.` durch `0 %` mit der Methode `replace()` aus pandas wie folgt:
```none
# Ersetzen Sie „N.A.” durch „0 %” in der Spalte „Urban Pop %”
df['Urban Pop %'] = df['Urban Pop %'].replace('N.A.', '0%')
```
### Prozentzeichen entfernen und Datentypen konvertieren
Die Spalten `„Yearly Change %”`, `„Urban Pop %”` und `„World Share %”` enthalten numerische Werte, denen ein Prozentzeichen folgt (*z. B.* `37,0 %`). Dies erschwert mathematische Operationen wie die Berechnung des Durchschnitts, des Maximums und der Standardabweichung für die Analyse.
Um dies zu beheben, können Sie die Methode `replace()` anwenden, um das `%-Zeichen` zu entfernen, und dann die Methode `astype()` anwenden, um sie für die Analyse in einen `Float-Datentyp` zu konvertieren:
```none
# Prozentzeichen entfernen und in Float konvertieren
df['Jährliche Veränderung %'] = df['Jährliche Veränderung %'].replace('%', '', regex=True).astype(float)
df['Stadtbevölkerung %'] = df['Stadtbevölkerung %'].replace('%', '', regex=True).astype(float)
df['Weltanteil %'] = df['Weltanteil %'].replace('%', '', regex=True).astype(float)
# Die ersten 5 Zeilen anzeigen
df.head()
```
Dieser Code entfernt das `%-Zeichen` aus den Werten in den Spalten `„Jährliche Veränderung %”`, `„Stadtbevölkerung %”` und `„Weltanteil %”` mithilfe der Methode `replace()` mit einem regulären Ausdruck. Anschließend werden die bereinigten Werte mit `astype(float)` in einen `Float-Datentyp` konvertiert. Zuletzt werden die ersten fünf Zeilen des DataFrame mit `df.head()` angezeigt.
Ihre Ausgabe sollte wie folgt aussehen:
### Kommas entfernen und Datentypen konvertieren
Derzeit enthalten die Spalten `„Population (2024)”`, `„Net Change”`, `„Density (P/Km²)”` und `„Land Area (Km²)`” sowie `„Migrants (net)` ” numerische Werte mit Kommas (*z. B.* 1.949.236). Dadurch ist es unmöglich, mathematische Operationen für die Analyse durchzuführen.
Um dies zu beheben, können Sie `replace()` und `astype()` anwenden, um Kommas zu entfernen und die Zahlen in den Datentyp „Ganzzahl” zu konvertieren:
```none
# Kommas entfernen und in Ganzzahlen konvertieren
columns_to_convert = [
'Population (2024)', 'Net Change', 'Density (P/Km²)', 'Land Area (Km²)',
'Migrants (net)'
]
for column in columns_to_convert:
# Sicherstellen, dass die Spalte zunächst als Zeichenfolge behandelt wird
df[column] = df[column].astype(str)
# Kommas entfernen
df[column] = df[column].str.replace(',', '')
# In Ganzzahlen konvertieren
df[column] = df[column].astype(int)
```
Dieser Code definiert eine Liste, `columns_to_convert`, die die Namen der zu verarbeitenden Spalten enthält. Für jede Spalte in der Liste wird sichergestellt, dass die Spaltenwerte mit `astype(str)` als Zeichenfolgen behandelt werden. Anschließend werden alle Kommas aus den Werten mit `str.replace(',', '')` entfernt und die bereinigten Werte mit `astype(int)` in Ganzzahlen konvertiert, sodass die Werte für mathematische Operationen geeignet sind.
### Ändern der Datentypen für numerische Spalten
Die Spalten `„Rank”`, `„Med. Age”` und `„Fert. Rate”` enthalten Daten, die als Objektdatentyp gespeichert sind, aber numerische Werte enthalten. Konvertieren Sie die Daten in diesen Spalten in Ganzzahl- oder Gleitkommadatentypen, um mathematische Operationen zu ermöglichen:
```none
# In Ganzzahl- oder Gleitkommadatentypen und Ganzzahlen konvertieren
df['Rank'] = df['Rank'].astype(int)
df['Med. Age'] = df['Med. Age'].astype(int)
df['Fert. Rate'] = df['Fert. Rate'].astype(float)
```
Dieser Code konvertiert die Werte in den Spalten `„Rank”` und `„Med. Age”` in einen Integer-Datentyp und die Werte in `„Fert. Rate”` in einen Float-Datentyp.
Überprüfen Sie abschließend mit der Methode `head()`, ob die bereinigten Daten die richtigen Datentypen aufweisen:
```none
print(df.head(10))
```
Ihre Ausgabe sollte wie folgt aussehen:
Nachdem die Daten nun bereinigt sind, können Sie verschiedene mathematische Operationen wie[Durchschnitt und Modus](https://www.w3schools.com/python/python_ml_mean_median_mode.asp) sowie analytische Methoden wie[Korrelation](https://www.w3schools.com/python/pandas/pandas_correlations.asp) anwenden, um die Daten zu untersuchen.
## Exportieren Sie die bereinigten Daten in eine CSV-Datei
Nach der Bereinigung Ihrer Daten ist es wichtig, die bereinigten Daten für die zukünftige Verwendung und Analyse zu speichern. Sie können die bereinigten Daten in eine CSV-Datei exportieren, wodurch Sie sie leicht mit anderen teilen oder mit verschiedenen unterstützten Tools und Software weiterverarbeiten/analysieren können.
Mit der Methode `to_csv()` in pandas können Sie die Daten aus einem DataFrame in eine CSV-Datei mit dem Namen `world_population_by_country.csv` exportieren:
```none
# Speichern Sie die Daten in einer Datei.
filename = 'world_population_by_country.csv'
df.to_csv(filename, index=False)
```
## Fazit
Mit dem Python-Paket Beautiful Soup können Sie HTML-Dokumente parsen und Daten aus einer HTML-Tabelle extrahieren. In diesem Artikel haben Sie gelernt, wie Sie Daten scrapen, bereinigen und in eine CSV-Datei exportieren können.
Obwohl dieses Tutorial recht einfach war, kann das Extrahieren von Daten aus komplexen Websites schwierig und zeitaufwändig sein. Beispielsweise erfordert die Arbeit mit paginierten HTML-Tabellen oder verschachtelten Strukturen, in denen Daten in über- und untergeordneten Elementen eingebettet sind, eine sorgfältige Analyse, um das Layout zu verstehen. Darüber hinaus können sich Website-Strukturen im Laufe der Zeit ändern, was eine kontinuierliche Pflege Ihres Codes und Ihrer Infrastruktur erforderlich macht.
Um Zeit zu sparen und die Arbeit zu vereinfachen, sollten Sie die Verwendung der[Bright Data Web Scraper API](/products/web-scraper) in Betracht ziehen. Dieses leistungsstarke Tool bietet eine vorgefertigte Scraping-Lösung, mit der Sie Daten aus komplexen Websites mit minimalen technischen Kenntnissen extrahieren können. Die API automatisiert die Datenerfassung und bewältigt Herausforderungen wie [dynamische Inhalte](/blog/how-tos/scrape-dynamic-websites-python), JavaScript-gerenderte Seiten und CAPTCHA-Verifizierung.
Melden Sie sich an und starten Sie Ihre kostenlose Testversion der Web Scraper API!
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=Wie+man+HTML-Tabellen+mit+Python+scrapt&u=https://brightdata.de/blog/web-data-de/how-to-scrape-html-tables) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Wie+man+HTML-Tabellen+mit+Python+scrapt&url=https://brightdata.de/blog/web-data-de/how-to-scrape-html-tables) [ ](http://www.reddit.com/submit?title=Wie+man+HTML-Tabellen+mit+Python+scrapt&url=https://brightdata.de/blog/web-data-de/how-to-scrape-html-tables)
## Das könnte Sie auch interessieren
[  ](https://brightdata.de/blog/ai/openhuman-with-bright-data "Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI")
[AI
Antonello Zanini
Technical Writer
### Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI
Integrieren Sie die Bright Data CLI mit OpenHuman, um produktionsreifen Web-Zugriff und Datenerhebung für KI-Agenten zu ermöglichen.
09-Sep-2026
12 min lesen
](https://brightdata.de/blog/ai/openhuman-with-bright-data)
[  ](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax "Multimodales Web-Scraping mit MiniMax")
[Web Data
Antonello Zanini
Technical Writer
### Multimodales Web-Scraping mit MiniMax
Kombinieren Sie Bright Data Web Unlocker mit MiniMax M3 Vision, um strukturierte Daten aus Bildern und Webseiten-Screenshots zu extrahieren.
09-Sep-2026
4 min lesen
](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax)
[  ](https://brightdata.de/blog/ai/best-cli-tools-for-codex "Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet")
[AI
Daniel Shashko
Web Data & AI Expert
### Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet
Die 10 CLI-Tools, die Codex schneller und leistungsfähiger machen, beginnend mit dem Bright Data CLI für echten Web-Zugriff aus der Sandbox heraus.
06-Sep-2026
20 min lesen
](https://brightdata.de/blog/ai/best-cli-tools-for-codex)
| | |