import requests
from bs4 import BeautifulSoup

# HTML-Snippet mit verschiedenen Attributen und Textstrukturen
sample_html = """
<div id="product-card" data-product-id="12345">
    <h3><a href="/item/super-widget" class="product-link">Super Widget <small>(Modell X)</small></a></h3>
    <p class="description">Ein <strong>fantastisches</strong> Produkt für jeden Entwickler.</p>
    <span class="price">Preis: <b>99.99</b> €</span>
    <img src="/images/widget.jpg" alt="Super Widget Bild" width="200">
</div>
"""
soup_sample = BeautifulSoup(sample_html, 'lxml')

# 1. Extrahieren von Attributwerten
print("--- Attributwerte extrahieren ---")
product_card = soup_sample.find('div', id='product-card')
if product_card:
    product_id = product_card.get('data-product-id')
    print(f"Produkt ID (data-product-id): {product_id}")

    product_link_tag = soup_sample.find('a', class_='product-link')
    if product_link_tag:
        link_href = product_link_tag.get('href') # Sicherer Zugriff
        link_class = product_link_tag['class'][0] # Wörterbuch-Zugriff, da 'class' eine Liste sein kann
        print(f"Link-URL (href): {link_href}")
        print(f"Link-Klasse (class): {link_class}")

    image_tag = soup_sample.find('img')
    if image_tag:
        image_src = image_tag.get('src')
        image_alt = image_tag.get('alt')
        print(f"Bild-URL (src): {image_src}")
        print(f"Bild-Alternativtext (alt): {image_alt}")

print("n--- Textinhalte extrahieren ---")
# 2. Extrahieren von Textinhalten
title_tag = soup_sample.find('h3')
if title_tag:
    # .string gibt hier None zurück, da das h3 mehrere Kind-Elemente hat (a, small)
    print(f"Titel (title_tag.string): {title_tag.string}") 
    # .text gibt den gesamten sichtbaren Textinhalt zurück
    print(f"Titel (title_tag.text): {title_tag.text.strip()}")
    # .get_text() ist flexibler
    print(f"Titel (title_tag.get_text(separator=' ', strip=True)): {title_tag.get_text(separator=' ', strip=True)}")

description_p = soup_sample.find('p', class_='description')
if description_p:
    # Hier gibt .text den gesamten Text inklusive des starken Textes zurück
    print(f"Beschreibung (description_p.text): {description_p.text.strip()}")

price_span = soup_sample.find('span', class_='price')
if price_span:
    # Den reinen Preis ohne "Preis:" extrahieren
    bold_price = price_span.find('b').string
    print(f"Extrahierter Preis: {bold_price} {price_span.get_text().replace('Preis:', '').replace(bold_price, '').strip()}")

    # Oder einfach den gesamten Text
    print(f"Preisspanne (price_span.text): {price_span.text.strip()}")

Praktisches Beispiel: Datenextraktion und Integration mit Pandas

Um die Leistungsfähigkeit von Beautiful Soup in einem realen Szenario zu demonstrieren, werden wir das im Referenzinhalt erwähnte Beispiel aufgreifen und vertiefen: das Extrahieren von globalen Bevölkerungsdaten von der Worldometer-Website. Dieses Beispiel illustriert den gesamten Workflow vom Senden einer HTTP-Anfrage über das Parsen der HTML-Antwort bis hin zur Umwandlung der extrahierten Daten in ein Pandas DataFrame und den Export als CSV-Datei. Dieser Prozess ist typisch für automatisierte Datenerfassung für Datenanalysten und Data Engineers, die strukturierte Datensätze für weitere Analysen benötigen.

Schritt-für-Schritt-Anleitung am Worldometer-Beispiel

Unser Ziel ist es, die Bevölkerungstabelle von Worldometer zu scrapen, die Informationen wie Land, Bevölkerung und jährliche Veränderung enthält. Dies ist ein hervorragendes Beispiel, um zu zeigen, wie Beautiful Soup mit HTML-Tabellen umgeht und wie man diese Daten anschließend mit Pandas verarbeitet.

Schritt 1: Notwendige Bibliotheken importieren
Zuerst importieren wir `requests` für die HTTP-Anfrage, `BeautifulSoup` zum Parsen und `pandas` zur Datenmanipulation.

Schritt 2: Die Ziel-URL definieren
Wir speichern die URL der Worldometer-Seite in einer Variable.

Schritt 3: HTTP-Anfrage senden und Fehlerbehandlung
Wir verwenden `requests.get()` um den HTML-Inhalt der Seite abzurufen. Eine robuste Implementierung sollte immer eine Fehlerbehandlung enthalten, um Probleme wie Netzwerkfehler oder nicht existierende Seiten abzufangen.

Schritt 4: HTML-Inhalt mit Beautiful Soup parsen
Der rohe HTML-Text wird an den `BeautifulSoup`-Konstruktor übergeben, um das parse-tree-Objekt zu erstellen.

Schritt 5: Die gewünschte Tabelle finden
Auf vielen Webseiten gibt es mehrere Tabellen. Wir müssen die richtige Tabelle identifizieren. In unserem Fall ist es die erste gefundene Tabelle, die die Bevölkerungsdaten enthält. Eine Inspektion des Seitenquellcodes (z.B. mit den Entwicklertools des Browsers) hilft oft, die richtige Tabelle anhand einer ID oder Klasse zu lokalisieren, was die Suche präziser macht.

Schritt 6: Daten in ein Pandas DataFrame umwandeln
Pandas bietet eine sehr bequeme Funktion, `pd.read_html()`, die direkt HTML-Tabellen in DataFrames umwandeln kann. Dies erspart das manuelle Iterieren über Zeilen und Spalten.

Schritt 7: Erste Datenzeilen anzeigen und exportieren
Mit `df.head()` können wir schnell einen Blick auf die ersten Zeilen des DataFrames werfen, um die erfolgreiche Extraktion zu überprüfen. Anschließend exportieren wir die Daten in eine CSV-Datei, was ein gängiges Format für die weitere Datenanalyse ist.

import requests
from bs4 import BeautifulSoup
import pandas as pd
import os # Für plattformunabhängige Dateipfade

# 1. URL der Zielseite für Weltbevölkerungsdaten
url = "https://www.worldometers.info/world-population/population-by-country/"
print(f"Starte Web Scraping für: {url}")

# 2. HTTP-Anfrage senden und auf Fehler prüfen
try:
    # Sende eine GET-Anfrage an die URL. Ein Timeout verhindert, dass das Skript bei Problemen ewig wartet.
    response = requests.get(url, timeout=15)
    # Prüfe auf HTTP-Fehler (z.B. 404 Not Found, 500 Server Error)
    response.raise_for_status() 
    print("Webseite erfolgreich abgerufen (HTTP Status 200).")
except requests.exceptions.HTTPError as errh:
    print(f"HTTP-Fehler aufgetreten: {errh}")
    exit() # Skript beenden, wenn kein Zugriff auf die Seite möglich ist
except requests.exceptions.ConnectionError as errc:
    print(f"Verbindungsfehler aufgetreten: {errc}")
    exit()
except requests.exceptions.Timeout as errt:
    print(f"Timeout-Fehler aufgetreten: {errt}")
    exit()
except requests.exceptions.RequestException as err:
    print(f"Ein unbekannter Fehler ist aufgetreten: {err}")
    exit()

# 3. HTML-Inhalt mit Beautiful Soup parsen
# Wir verwenden 'lxml' als Parser, da er in der Regel schneller und robuster ist.
# Wenn 'lxml' nicht installiert ist, kann 'html.parser' verwendet werden.
soup = BeautifulSoup(response.text, 'lxml')
print("HTML-Inhalt erfolgreich geparst.")

# 4. Die gewünschte Tabelle finden
# Die Worldometer-Seite enthält eine Tabelle mit ID 'example2' für die Bevölkerungsdaten.
# Eine spezifische Suche nach ID oder Klasse ist robuster als das erste beliebige 'table'-Tag.
data_table = soup.find("table", id="example2") # Findet die Tabelle anhand ihrer ID
if data_table is None:
    print("Fehler: Tabelle mit ID 'example2' nicht gefunden.")
    # Fallback, falls ID sich ändert oder nicht vorhanden:
    # print("Versuche, die erste Tabelle zu finden...")
    # data_tables = soup.find_all("table")
    # if data_tables:
    #     data_table = data_tables[0]
    # else:
    #     print("Keine Tabellen auf der Seite gefunden.")
    exit()

print("Ziel-Tabelle gefunden.")

# 5. Daten in ein Pandas DataFrame umwandeln
# pd.read_html() gibt eine Liste von DataFrames zurück, auch wenn nur eine Tabelle gefunden wird.
try:
    df_population = pd.read_html(str(data_table))[0]
    print("Daten erfolgreich in Pandas DataFrame umgewandelt.")
except ValueError as e:
    print(f"Fehler beim Umwandeln der Tabelle in DataFrame: {e}")
    exit()

# 6. Erste Zeilen des DataFrames anzeigen
print("nErste 5 Zeilen des extrahierten DataFrames:")
print(df_population.head())

# Optional: Spaltennamen bereinigen oder anpassen für bessere Lesbarkeit
# Zum Beispiel: Entfernen des ersten unbenannten Indexes, der oft von read_html hinzugefügt wird.
if 'Unnamed: 0' in df_population.columns:
    df_population = df_population.drop(columns=['Unnamed: 0'])

# Spalten umbenennen, falls die Webseite nicht eindeutige Namen liefert
new_column_names = {
    '#': 'Rank',
    'Country (or dependency)': 'Land',
    'Population (2023)': 'Bevölkerung_2023',
    'Yearly Change': 'Jährliche_Veränderung',
    'Net Change': 'Netto_Veränderung',
    'Density (P/Km²)': 'Dichte_P_Km2',
    'Land Area (Km²)': 'Landfläche_Km2',
    'Migrants (net)': 'Migranten_Netto',
    'Fert. Rate': 'Fertilitätsrate',
    'Med. Age': 'Median_Alter',
    'Urban Pop %': 'Städtische_Bevölkerung_Proz',
    'World Share': 'Weltanteil'
}
df_population = df_population.rename(columns=new_column_names)

print("nDataFrame nach Spaltenbereinigung und Umbenennung (erste 5 Zeilen):")
print(df_population.head())

# 7. Daten in eine CSV-Datei exportieren
output_directory = "scraped_data"
# Erstelle das Verzeichnis, falls es nicht existiert
os.makedirs(output_directory, exist_ok=True) 
csv_filename = "world_population_data_detailed.csv"
csv_filepath = os.path.join(output_directory, csv_filename)

try:
    # 'index=False' verhindert, dass der Pandas-Index als Spalte in die CSV geschrieben wird.
    # 'header=True' schreibt die Spaltennamen in die erste Zeile der CSV-Datei.
    df_population.to_csv(csv_filepath, index=False, header=True, encoding='utf-8')
    print(f"nDaten erfolgreich nach '{csv_filepath}' exportiert.")
except Exception as e:
    print(f"Fehler beim Exportieren der Daten in CSV: {e}")

print("nWeb Scraping Prozess abgeschlossen.")

Nachdem die Daten nun in einem strukturierten DataFrame vorliegen und als CSV gespeichert wurden, kann der Datenanalyse-Workflow fortgesetzt werden. Dies könnte die explorative Datenanalyse (EDA), die Entwicklung von Machine-Learning-Modellen zur Vorhersage von Bevölkerungstrends oder die Integration in ein größeres Data Warehouse umfassen. Die Möglichkeiten sind vielfältig und hängen von den spezifischen Forschungsfragen und Zielen ab.

Die transformative Kraft des Web Scrapings

Web Scraping mit Python und Beautiful Soup ist eine unverzichtbare Fähigkeit in der modernen Datenlandschaft. Es befähigt Entwickler, Studenten und Technologiebegeisterte, das Internet als eine riesige Datenbank zu nutzen, um Informationen zu extrahieren, die für Analysen und datengestützte Entscheidungen entscheidend sind. Von der einfachen Datenextraktion von Webseiten bis zur komplexen automatisierte Informationsbeschaffung bietet Beautiful Soup eine elegante und effiziente Lösung für das Parsen von HTML- und XML-Dokumenten.