Wikipedia mit Python scrapenArtikel, Tabellen und Infoboxen

Wikipedia ist das größte Nachschlagewerk, das je zusammengestellt wurde, und fast alles darin ist auf dieselbe Weise strukturiert: ein Titel, eine einleitende Zusammenfassung, eine Abfolge von Abschnittsüberschriften, eine Infobox mit wichtigen Fakten und beliebig viele Datentabellen. Diese Regelmäßigkeit macht Wikipedia zu einer der nützlichsten öffentlichen Quellen im Web für Recherche, Content-Anreicherung, Wissensgraphen und Trainingsdatensätze. Diese Anleitung zeigt Ihnen, wie Sie Wikipedia mit Python scrapen können, auf saubere und reproduzierbare Weise.

Alles hier beschränkt sich auf öffentliche Enzyklopädieinhalte: Artikeltitel, einleitende Zusammenfassungen, Abschnittsüberschriften, Infobox-Felder und Tabellen, die jeder ohne Anmeldung lesen kann. Wir werden einen kleinen Scraper entwickeln, der eine gerenderte Artikelseite über die Crawling API abruft, diese Felder mit BeautifulSoup analysiert und sie nach JSON und CSV exportiert. Wikipedia-Texte sind unter CC-BY-SA frei lizenziert. Bevor Sie dies auf etwas Reales anwenden, lesen Sie bitte den Abschnitt zu Zuschreibung und Rechtmäßigkeit am Ende und erwägen Sie die offizielle MediaWiki-API, die für die meisten Projekte der empfohlene Weg ist.

Was Sie bauen werden

Ein Python-Skript, das eine Wikipedia-Artikel-URL entgegennimmt, die Seite über die Crawling API abruft und eine Handvoll strukturierter Felder analysiert:

• Artikeltitel die Seitenüberschrift aus dem firstHeading-Element.
• Zusammenfassung die einleitenden Absätze am Anfang des Artikels.
• Abschnittsüberschriften die h2- und h3-Überschriften, die den Artikel gliedern.
• Infobox-Felder die Label-Wert-Paare aus der seitlichen Infobox (Geburtsdatum, Staatsangehörigkeit, Beruf usw.).
• Tabellen die Wikitabellen-Datentabellen, geparst in Zeilen, die Sie in CSV schreiben können.

Jedes Feld wird einer stabilen Wikipedia-CSS-Klasse oder einem Element-ID zugeordnet, sodass der Scraper auf den meisten Artikelseiten funktioniert, nicht nur auf einer.

Warum über die Crawling API scrapen

Eine Wikipedia-Artikelseite ist größtenteils server-gerendertes HTML, sodass eine einfache Anfrage oft verwendbares Markup zurückgibt. Die Probleme zeigen sich im größeren Maßstab. Wikimedia bittet automatisierte Clients, sich zu identifizieren, hält Rate-Limits strikt ein und wird Traffic drosseln oder blockieren, der seine Server von einer einzigen Adresse aus stark belastet. Wenn Sie eine enge Schleife von einer Datacenter-IP aus betreiben, werden Sie diese Limits schnell erreichen, und eine gesperrte IP stoppt den gesamten Vorgang.

Das Routing von Anfragen über die Crawling API löst die operative Seite. Sie senden ihr die Artikel-URL, sie ruft die Seite hinter einem rotierenden Pool vertrauenswürdiger IPs ab, verarbeitet Wiederholungsversuche und gibt fertiges HTML zurück, das Sie parsen können. Das verhindert, dass eine einzelne Adresse ein Rate-Limit auslöst, und bedeutet, dass Sie selbst keinen Proxy-Pool pflegen müssen. Der nachfolgend beschriebene Parsing-Ansatz ist derselbe, den Sie gegenüber jeder HTML-Quelle verwenden würden. Falls Sie damit noch nicht vertraut sind, behandelt unser Leitfaden zu BeautifulSoup in Python die Extraktionsseite ausführlich.

Voraussetzungen

Einige Dinge müssen zuerst eingerichtet sein. Keines davon dauert lange.

Python-Grundkenntnisse. Sie sollten mit dem Ausführen eines Skripts und dem Installieren von Paketen mit pip vertraut sein. Kenntnisse der HTML-Struktur sind hilfreich, da es bei der ganzen Aufgabe darum geht, Elemente nach Klasse und ID zu targeten.

Python 3.8 oder höher. Prüfen Sie mit python --version. Falls Sie es nicht haben, installieren Sie es von python.org.

Ein Crawlbase-Konto und Token. Melden Sie sich an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token von der Konto-Dokumentationsseite. Wikipedia ist statisches HTML, daher ist das normale Anfrage-Token hier die richtige Wahl; Sie benötigen kein JavaScript-Rendering. Halten Sie das Token außerhalb der Versionsverwaltung.

Das Projekt einrichten

Erstellen Sie eine isolierte virtuelle Umgebung und installieren Sie dann die drei Bibliotheken, die der Scraper benötigt.

python --version

python -m venv wikipedia_env
source wikipedia_env/bin/activate

pip install crawlbase beautifulsoup4 pandas

Unter Windows aktivieren Sie mit wikipedia_env\Scripts\activate statt der source-Zeile. Drei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, beautifulsoup4 analysiert das zurückgegebene HTML, und pandas wandelt die Infobox und Tabellen in Frames um, die Sie als CSV schreiben können.

Schritt 1: Das Artikel-HTML abrufen

Beginnen Sie damit, die rohe Seite abzurufen. Importieren Sie CrawlingAPI, initialisieren Sie es mit Ihrem Token und fordern Sie eine Artikel-URL an. Prüfen Sie den Statuscode vor dem Parsen, damit Fehler laut statt still bleiben. Wir verwenden den Wikipedia-Artikel über Ada Lovelace als laufendes Beispiel, da er eine reichhaltige Infobox und mehrere Tabellen hat.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    response = api.get(page_url)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    page_url = "https://en.wikipedia.org/wiki/Ada_Lovelace"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Führen Sie dies aus und Sie sollten den Anfang des HTML des Artikels in Ihrem Terminal sehen. Das bestätigt, dass die Anfrage funktioniert hat, und gibt Ihnen fertiges Markup zum Parsen. Das CrawlingAPI-Objekt wird einmal erstellt und wiederverwendet, was das gewünschte Muster ist, wenn Sie später viele Seiten in einer Schleife abrufen.

Schritt 2: Titel und Zusammenfassung parsen

Mit HTML in der Hand laden Sie es in BeautifulSoup. Wikipedia gibt der Seitenüberschrift die ID firstHeading, und die einleitende Zusammenfassung ist die Folge von Absätzen im Hauptinhalt vor der ersten Abschnittsüberschrift. Wir holen den Titel aus dieser ID und sammeln dann die einleitenden Absätze als Zusammenfassung.

from bs4 import BeautifulSoup

def parse_title_and_summary(html):
    soup = BeautifulSoup(html, "html.parser")

    title = soup.find("h1", id="firstHeading").get_text(strip=True)

    content = soup.find("div", class_="mw-parser-output")
    summary = []
    for p in content.find_all("p", recursive=False):
        text = p.get_text(strip=True)
        if text:
            summary.append(text)
        if len(summary) >= 3:
            break

    return title, " ".join(summary)

Der Aufruf find('h1', id='firstHeading') zielt genau auf den Seitentitel ab, denselben Selektor, den Sie beim Inspizieren der Seite in den Entwicklertools Ihres Browsers finden würden. Für die Zusammenfassung gehen wir die direkten untergeordneten Absätze von mw-parser-output durch, dem Wrapper um den Artikelkörper, und nehmen die ersten nicht leeren. Die Begrenzung auf drei hält die einleitende Einführung, ohne den gesamten Artikel in eine Zeichenkette zu ziehen.

Schritt 3: Die Abschnittsüberschriften sammeln

Wikipedia gliedert jeden Artikel mit einer konsistenten Überschriftenstruktur. In der gerenderten Seite sitzt der Titeltext des Abschnitts in Elementen mit der Klasse mw-headline, verschachtelt unter h2- und h3-Tags. Das Sammeln dieser ergibt das Inhaltsverzeichnis in Dokumentreihenfolge.

def parse_sections(soup):
    sections = []
    for tag in soup.find_all(["h2", "h3"]):
        headline = tag.find("span", class_="mw-headline")
        if headline:
            sections.append({
                "level": tag.name,
                "heading": headline.get_text(strip=True),
            })
    return sections

Wir erfassen nur Überschriften, die ein mw-headline-Span enthalten, was nicht zusammenhängende h2- und h3-Tags im Seitenchrome herausfiltert und die echten Artikelabschnitte beibehält. Das Erfassen der Ebene ermöglicht es Ihnen, die Hierarchie später neu aufzubauen: h2 für Abschnitte der obersten Ebene, h3 für Unterabschnitte.

Schritt 4: Die Infobox-Felder extrahieren

Die Infobox ist die eingerahmte Zusammenfassung der wichtigsten Fakten auf der rechten Seite vieler Artikel. Wikipedia kennzeichnet sie mit der infobox-Klasse, und jede Tatsache ist eine Tabellenzeile, die eine Beschriftungszelle (infobox-label) mit einer Datenzelle (infobox-data) verbindet. Das Durchlaufen dieser Zeilen verwandelt die Infobox in ein sauberes Wörterbuch mit Feldern.

def parse_infobox(soup):
    infobox = soup.find("table", class_="infobox")
    if not infobox:
        return {}

    fields = {}
    for row in infobox.find_all("tr"):
        label = row.find("th", class_="infobox-label")
        data = row.find("td", class_="infobox-data")
        if label and data:
            key = label.get_text(strip=True)
            value = data.get_text(" ", strip=True)
            fields[key] = value

    image = infobox.select_one(".infobox-image img")
    if image and image.has_attr("src"):
        fields["image"] = "https:" + image["src"]

    return fields

Jedes infobox-label- und infobox-data-Paar wird zu einem Schlüssel-Wert-Eintrag, sodass die Infobox einer Person Felder wie Born, Died, Resting place, Citizenship und Occupation liefert, ohne dass Sie sie im Voraus benennen müssen. Der Aufruf get_text(" ", strip=True) verbindet mehrzeilige Werte mit einem Leerzeichen, was Listen wie mehrere Nationalitäten in einer Zeile lesbar hält. Wir holen auch das Leitbild aus .infobox-image img und stellen https: voran, weil Wikipedia Bild-URLs protokoll-relativ bereitstellt.

Schritt 5: Die Datentabellen parsen

Artikeltabellen verwenden die wikitable-Klasse. Pandas liest HTML-Tabellen direkt, daher ist der sauberste Ansatz, das HTML jeder Tabelle an pandas.read_html zu übergeben und es einen DataFrame zurückgeben zu lassen. Das gibt Ihnen Zeilen und Spalten, bereit für CSV, mit fast keinem manuellen Zellen-Durchlaufen. Wenn Sie die allgemeine Technik über Wikipedia hinaus möchten, lesen Sie unseren Leitfaden zum Scrapen von Tabellen von einer Website.

import pandas as pd
from io import StringIO

def parse_tables(soup):
    tables = []
    for node in soup.find_all("table", class_="wikitable"):
        try:
            df = pd.read_html(StringIO(str(node)))[0]
            tables.append(df)
        except ValueError:
            continue
    return tables

Wir durchlaufen jede wikitable, übergeben ihr HTML an read_html und behalten den ersten DataFrame, den es für jede zurückgibt. Das Einwickeln des Aufrufs in ein try bedeutet, dass eine fehlerhafte Tabelle übersprungen statt den Lauf zu unterbrechen wird. Das Ergebnis ist eine Liste von DataFrames, einer pro Tabelle, die Sie in separate CSV-Dateien schreiben oder nach Bedarf zusammenführen können. Zum Bereinigen dieser Frames vor der weiteren Verwendung behandelt unser Leitfaden zum Strukturieren und Bereinigen von Web-Scraped-Daten für AI und ML die üblichen Schritte.

Schritt 6: Alles zusammensetzen und exportieren

Verbinden Sie nun die Teile zu einem ausführbaren Skript. Es ruft den Artikel ab, analysiert jedes Feld, schreibt die strukturierten Daten nach JSON und schreibt jede Tabelle in ihre eigene CSV-Datei.

import json
from io import StringIO
import pandas as pd
from bs4 import BeautifulSoup
from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    response = api.get(page_url)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['status_code']}")
    return None

def scrape_article(html):
    soup = BeautifulSoup(html, "html.parser")

    title = soup.find("h1", id="firstHeading").get_text(strip=True)

    content = soup.find("div", class_="mw-parser-output")
    summary = []
    for p in content.find_all("p", recursive=False):
        text = p.get_text(strip=True)
        if text:
            summary.append(text)
        if len(summary) >= 3:
            break

    sections = []
    for tag in soup.find_all(["h2", "h3"]):
        headline = tag.find("span", class_="mw-headline")
        if headline:
            sections.append(headline.get_text(strip=True))

    infobox = {}
    box = soup.find("table", class_="infobox")
    if box:
        for row in box.find_all("tr"):
            label = row.find("th", class_="infobox-label")
            data = row.find("td", class_="infobox-data")
            if label and data:
                infobox[label.get_text(strip=True)] = data.get_text(" ", strip=True)

    tables = []
    for node in soup.find_all("table", class_="wikitable"):
        try:
            tables.append(pd.read_html(StringIO(str(node)))[0])
        except ValueError:
            continue

    return {
        "title": title,
        "summary": " ".join(summary),
        "sections": sections,
        "infobox": infobox,
    }, tables

def main():
    page_url = "https://en.wikipedia.org/wiki/Ada_Lovelace"
    html = crawl(page_url)
    if not html:
        return

    article, tables = scrape_article(html)
    article["source_url"] = page_url
    article["license"] = "CC BY-SA 4.0"

    with open("wikipedia.json", "w", encoding="utf-8") as f:
        json.dump(article, f, indent=2, ensure_ascii=False)

    for i, df in enumerate(tables):
        df.to_csv(f"wikipedia_table_{i}.csv", index=False)

    print(json.dumps(article, indent=2, ensure_ascii=False))
    print(f"Saved {len(tables)} table(s) to CSV")

if __name__ == "__main__":
    main()

Das Skript schreibt Titel, Zusammenfassung, Abschnitte und Infobox in wikipedia.json und jede wikitable in ihre eigene nummerierte CSV. Beachten Sie die zwei zusätzlichen Felder, die wir vor dem Speichern hinzufügen: source_url und license. Das Aufzeichnen, woher die Daten stammen und dass sie unter CC-BY-SA lizenziert sind, ist keine optionale Buchführung, sondern die Voraussetzung, um die Zuschreibungspflicht zu erfüllen, die der Abschnitt zur Rechtmäßigkeit unten behandelt.

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript aus und die JSON-Datei enthält einen sauberen, strukturierten Datensatz des Artikels.

{
  "title": "Ada Lovelace",
  "summary": "Augusta Ada King, Countess of Lovelace, was an English mathematician and writer...",
  "sections": [
    "Biography",
    "Work",
    "Commemoration",
    "In popular culture"
  ],
  "infobox": {
    "Born": "Augusta Ada Byron 10 December 1815 London, England",
    "Died": "27 November 1852 (aged 36) Marylebone, London, England",
    "Occupation": "Mathematician"
  },
  "source_url": "https://en.wikipedia.org/wiki/Ada_Lovelace",
  "license": "CC BY-SA 4.0"
}

Daneben erhalten Sie eine CSV pro Tabelle, benannt nach wikipedia_table_0.csv, wikipedia_table_1.csv usw., jeweils mit der Kopfzeile und den Datenzeilen, die pandas geparst hat. Von hier aus speist das JSON eine Wissensdatenbank oder Content-Pipeline, und die CSVs lassen sich direkt in eine Tabellenkalkulation oder eine Datenbank einfügen.

Skalierung auf viele Artikel

Um einen Datensatz aufzubauen, wickeln Sie die Abruf-und-Parse-Schleife über eine Liste von Artikel-URLs und takten die Anfragen. Wikipedia reagiert empfindlich auf stoßartigen Traffic, daher hält Sie eine kleine Verzögerung zwischen Seiten als höflichen Client.

import time

urls = [
    "https://en.wikipedia.org/wiki/Ada_Lovelace",
    "https://en.wikipedia.org/wiki/Alan_Turing",
    "https://en.wikipedia.org/wiki/Grace_Hopper",
]

dataset = []
for url in urls:
    html = crawl(url)
    if html:
        article, _ = scrape_article(html)
        article["source_url"] = url
        dataset.append(article)
    time.sleep(2)

print(f"Collected {len(dataset)} articles")

Das time.sleep(2) zwischen Anfragen ist die wichtigste Gewohnheit, wenn Sie in beliebigem Umfang von Wikipedia sammeln. Takten Sie Ihren Lauf, halten Sie Batches bescheiden und hören Sie auf, wenn Sie das benötigte Sample haben. Für große strukturierte Abrufe sind jedoch die MediaWiki-API und die Datenbankdumps genuinen schneller und leichter für Wikimedias Server, und wir empfehlen sie als Nächstes.

Ist es legal, Wikipedia zu scrapen?

Wikipedia ist eine der zugelasseneren großen Seiten, da sein Textinhalt frei unter Creative Commons Attribution-ShareAlike (CC-BY-SA) lizenziert ist. Das bedeutet, dass Sie Artikeltext wiederverwenden und sogar weiterverbreiten dürfen, auch in kommerziellen Projekten, unter zwei Bedingungen: Sie nennen die Quelle (Wikipedia und die Autoren, typischerweise mit einem Link zum Artikel), und Sie teilen jede abgeleitete Arbeit unter derselben Lizenz. Einige eingebettete Medien, wie bestimmte Bilder, haben ihre eigene separate Lizenz, also prüfen Sie die Dateiseite, bevor Sie ein Bild wiederverwenden. Die Felder license und source_url, die das Skript aufzeichnet, existieren genau dafür, damit Sie die Zuschreibungspflicht im Nachhinein erfüllen können.

Freizügige Lizenzierung ist keine Lizenz, die Server zu ignorieren. Wikimedias Nutzungsbedingungen verlangen von automatisierten Clients, Rate-Limits zu respektieren, sich zu identifizieren und den Dienst für menschliche Leser nicht zu beeinträchtigen. Die Website in einer engen Schleife zu hämmern ist sowohl unhöflich als auch geeignet, Ihre IP zu sperren. Halten Sie das Volumen bescheiden, takten Sie Ihre Anfragen wie oben gezeigt und lesen Sie die robots.txt der Website. Dieses Tutorial beschränkt sich ausschließlich auf öffentliche Enzyklopädieinhalte; es berührt keine Benutzerkonten-Seiten, Bearbeitungshistorien einzelner Personen oder irgendetwas hinter einer Authentifizierung.

Für alles über eine Handvoll Seiten hinaus ist der empfohlene Weg das offizielle Tooling. Die MediaWiki-API gibt strukturierte Artikelinhalte zurück, einschließlich geparster Abschnitte und Infobox-Daten, ohne dass Sie gerendertes HTML scrapen müssen, und Wikimedia veröffentlicht auch vollständige Datenbankdumps der gesamten Enzyklopädie für die Massennutzung. Beide sind schneller, stabiler und wesentlich leichter für Wikimedias Infrastruktur als HTML-Scraping im Maßstab. Greifen Sie auf HTML-Scraping zurück, wenn Sie genau das benötigen, was ein Leser auf einer einzelnen Seite sieht; greifen Sie auf die API oder die Dumps zurück, wenn Sie Volumen benötigen.

Häufig gestellte Fragen

Benötige ich das JavaScript-Token, um Wikipedia zu scrapen?

Nein. Wikipedia-Artikelseiten sind server-gerendertes statisches HTML, daher reicht das normale Anfrage-Token aus. Das JavaScript-Token existiert für clientseitig gerenderte Seiten, die ihren Inhalt im Browser aufbauen, was Wikipedia nicht tut. Die Verwendung des normalen Tokens hält jede Anfrage leichter und vermeidet den zusätzlichen Rendering-Schritt.

Wie extrahiere ich die Infobox-Felder zuverlässig?

Suchen Sie das table.infobox-Element und durchlaufen Sie dann seine Zeilen, indem Sie jedes th.infobox-label mit seiner td.infobox-data-Zelle koppeln. Diese Label-Wert-Struktur ist über Artikel hinweg konsistent, sodass dieselbe Schleife die Infobox einer Person, eines Landes oder eines Films in ein sauberes Wörterbuch verwandelt, ohne Feldnamen hart zu kodieren.

Kann ich Wikipedia-Tabellen in CSV scrapen?

Ja. Wählen Sie jede table.wikitable, übergeben Sie das HTML jeder an pandas.read_html und Sie erhalten einen DataFrame pro Tabelle, den Sie mit to_csv ausgeben. Das Einwickeln des Lesevorgangs in ein try bedeutet, dass eine fehlerhafte Tabelle übersprungen statt den Lauf zu stoppen wird.

Ist es legal, gescrapten Wikipedia-Inhalt kommerziell zu nutzen?

Wikipedia-Text ist unter CC-BY-SA lizenziert, was kommerzielle Weiterverwendung erlaubt, solange Sie Wikipedia und die Autoren nennen und abgeleitete Arbeit unter derselben Lizenz teilen. Eingebettete Medien können ihre eigene Lizenz haben, also prüfen Sie jede Datei, bevor Sie Bilder wiederverwenden. Zeichnen Sie die Quell-URL und Lizenz mit Ihren Daten auf, damit die Zuschreibung später unkompliziert ist.

Sollte ich stattdessen die MediaWiki-API verwenden, anstatt zu scrapen?

Für alles im Volumen, ja. Die MediaWiki-API gibt strukturierte Artikelinhalte direkt zurück, und Wikimedia veröffentlicht vollständige Datenbankdumps für die Massennutzung. Beide sind schneller und wesentlich leichter für Wikipedias Server als HTML-Scraping. HTML-Scraping ist das richtige Werkzeug, wenn Sie genau das benötigen, was ein Leser auf einer bestimmten Seite sieht; API und Dumps sind besser zum Aufbau großer Datensätze.

Wie vermeide ich, beim Scrapen von Wikipedia gesperrt zu werden?

Halten Sie Ihre Anfragerate niedrig, fügen Sie wie im Skalierungsabschnitt gezeigt eine echte Verzögerung zwischen Seiten ein und routen Sie über rotierende IPs, damit keine einzelne Adresse gedrosselt wird. Die Crawling API übernimmt Rotation und Wiederholungsversuche für Sie. Lesen Sie die robots.txt der Website, halten Sie Batches bescheiden und bevorzugen Sie für große Aufgaben die offizielle API oder Dumps, um ein höflicher Client zu bleiben.

MA

Muhammad Atif

Senior Full Stack Developer · Crawlbase

Senior Full Stack Developer bei Crawlbase, der die Plattform aufbaut und über Scraping-Architektur, Proxys und Datenpipelines schreibt.

IK

Ian Kalvin

Technical Support Engineer · Crawlbase

Technical Support Engineer bei Crawlbase, der von der Front darüber schreibt, was beim Scraping und bei Proxy-Setups im Produktivbetrieb tatsächlich kaputtgeht.