Python Text aus HTML extrahieren

Die meisten Teams, die mit Python Text aus HTML extrahieren wollen, beginnen mit einem Einzeiler, stoßen in dem Moment an ihre Grenzen, in dem eine echte Seite erscheint, und verbringen dann einen Nachmittag damit, festzustellen, dass get_text() glücklicherweise JavaScript, Cookie-Banner und 47 Kopien des Wortes „Abonnieren“ zurückgibt. Die Lösung ist keine andere „magische“ Bibliothek. Es ist ein klarer Arbeitsablauf: Parsen, Bereinigen, Extrahieren, Normalisieren, Speichern.

HTML ist der Quellcode hinter einer Webseite. Er vermischt den eigentlichen gewünschten Inhalt – Überschriften, Absätze, Listenelemente – mit strukturellen Markups, Skripten, Stilen und Metadaten, die der Browser benötigt, Sie aber nicht. Extrahierter Text ist der sichtbare, für Menschen lesbare Teil dieser Seite, von dem die Markups entfernt wurden. Alles, was das DOM durchläuft – den Baum aus Knoten, den ein Parser aus rohem HTML aufbaut –, kann dies tun, wenn man ihm mitteilt, welche Knoten beibehalten werden sollen.

Dieser Leitfaden richtet sich an Python-Entwickler, Dateningenieure und NLP-Praktiker, die lauffähigen Code, sinnvolle Standardeinstellungen und ehrliche Kompromisse wünschen. Wir werden die Bibliotheken vergleichen, die tatsächlich von Bedeutung sind (BeautifulSoup, lxml.html sowie html-text, Parsel und Regex), erstellen wiederverwendbare Hilfsfunktionen für die Bereinigung und Normalisierung und fügen die Teile dann zu einem kleinen Crawler zusammen. Dabei werden auch JavaScript-gerenderte Seiten, Fallstricke bei der Kodierung und eine Tabelle zur Fehlerbehebung mit Symptomen und Lösungen behandelt.

Wenn Sie sagen, Sie möchten mit Python Text aus HTML extrahieren, meinen Sie eigentlich: Durchlaufen Sie das geparste Dokument, behalten Sie die sichtbaren Textknoten und verwerfen Sie alles andere. Browser tun dies implizit jedes Mal, wenn sie eine Seite rendern. Als Entwickler müssen wir dies explizit tun.

Ein paar Definitionen sollten wir festhalten, damit der Rest des Artikels Sinn ergibt:

• HTML ist die Rohquelle: Tags, Attribute, Inline-Stile, Skripte und Metadaten sowie der eigentliche Inhalt, der dazwischen steht.
• Tags sind einzelne Markierungen wie <p> und </p>. Elemente sind Tags plus alles, was sich in ihnen befindet.
• Das DOM (Document Object Model) ist der Baum, den ein Parser aus dieser Quelle aufbaut. Jedes Element, Attribut und jeder Textknoten wird zu einem Knoten in diesem Baum.
• Extrahierter Text ist der für Menschen lesbare Inhalt auf Blatt-Ebene: Überschriften, Absätze, Listenelemente, Beschriftungen, wobei die Markup-Elemente entfernt wurden.

Die Textextraktion funktioniert, indem das DOM durchlaufen und nur die Textknoten gesammelt werden, während Elemente wie <script> und <style>. Verschiedene Bibliotheken stellen diesen Durchlauf unterschiedlich dar, aber das mentale Modell ist dasselbe. Wenn Sie Parsen, Bereinigen, Extrahieren und Normalisieren in Ihrem Kopf als vier separate Schritte betrachten, können Sie zwischen BeautifulSoup, lxml, html-textund sogar nicht-Python-basierten Stacks wechseln, ohne das Problem neu lernen zu müssen.

Es spielt auch eine Rolle, warum Sie Text extrahieren. Ein Suchindex kommt mit einer einzigen flachen Zeichenkette zurecht. Eine LLM-Aufnahmepipeline möchte in der Regel, dass Absätze erhalten bleiben. Ein Analyseexport benötigt wahrscheinlich eine Trennung von Überschriften und Fließtext. Entscheiden Sie sich frühzeitig dafür, da dies beeinflusst, welche Bibliothek und welche Extraktionsstrategie sinnvoll ist.

Es gibt keine einzige „beste“ Antwort für das Extrahieren von Text aus HTML in Python, aber es gibt gute Standardoptionen und schlechte Entscheidungen. Hier ist ein Überblick darüber, wie sich die wichtigsten Optionen in der Praxis darstellen.

BeautifulSoup (bs4) ist der übliche Ausgangspunkt. Es ist tolerant gegenüber fehlerhaftem HTML, hat eine kleine API-Oberfläche (find, find_all, select, get_text) und ist für Leser geeignet, die noch nie mit XPath zu tun hatten. Es ist die richtige Wahl für Ad-hoc-Scraping, Prototypen und die meisten Produktionsaufträge, bei denen die Parsergeschwindigkeit kein Engpass ist. Die beiden Fallstricke, in die man geraten kann, sind das Vergessen, <script> und <style> vor dem Aufruf von get_text(), sowie das Belassen des Standard- html.parser Backend beizubehalten, obwohl sie lxml und 'lxml'.

lxml.html ist die schnelle, strenge, C-basierte Option. Es nutzt intern libxml2, stellt sowohl CSS-Selektoren als auch XPath zur Verfügung und ist die erste Wahl, wenn Sie Tausende von Seiten pro Minute parsen oder präzise DOM-Bearbeitungen vornehmen müssen. Der Nachteil ist eine etwas steilere Lernkurve und eine geringere Toleranz gegenüber fehlerhaftem Markup als bei BeautifulSoup. Laut der lxml-Dokumentation kann es fehlerhaftes HTML über sein html Modul analysieren, doch BeautifulSoup ist immer noch benutzerfreundlicher, wenn die Eingabe wirklich chaotisch ist.

html-text ist ein kleines Hilfsprogramm, das auf lxml und sauberen Klartext mit sinnvoller Leerzeichenbehandlung erzeugt. Es ist die richtige Wahl, wenn Sie meist „lesbaren Text aus diesem Datenklumpen“ mit minimaler Nachbearbeitung wollen und keine umfangreichen Abfragen benötigen. Es isoliert den Hauptartikeltext allein nicht zuverlässig, passt daher gut zu einem <main> oder <article> Selektor kombinieren.

Parsel ist die selektorlastige Bibliothek, die Scrapy antreibt. Sie glänzt, wenn Sie strukturierte Felder (Titel, Preis, Autor) über CSS oder XPath abrufen möchten, nicht jedoch, wenn Sie eine Textwand bereinigen wollen. Zum Zeitpunkt der Erstellung dieses Artikels war die Veröffentlichungsfrequenz relativ gering; überprüfen Sie daher, ob die Version auf PyPI noch zu Ihrem Stack passt, bevor Sie sie für ein neues Projekt einsetzen.

Regex ist kein Parser. Verwenden Sie es zur Bereinigung bereits extrahierter Zeichenfolgen (NBSP, wiederholte Leerzeichen, Anführungszeichen) und akzeptieren Sie, dass jeder Versuch, verschachteltes HTML mit re scheitern wird, sobald es um echte Markups geht.

Schnelle Entscheidungsregeln: Wenn du neu im Scraping bist, fang mit BeautifulSoup an. Wenn du nur sauberen Text ohne Abfragen brauchst, greif zu html-text. Wenn du Zehntausende von Seiten parsen musst oder XPath benötigst, wechsle zu lxml.html. Wenn du eher Typ-Felder als Text benötigst, verwende Parsel. Betrachte Regex als Hausmeister, niemals als Parser.

Alle folgenden Beispiele verwenden denselben unübersichtlichen Codeausschnitt, damit du die Bibliotheken fair vergleichen kannst. Speichere ihn als sample.html oder weisen Sie es einer Zeichenkette zu:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>How to brew filter coffee</title>
  <style>.ad{color:red}</style>
  <script>window.analytics={track:()=>{}}</script>
</head>
<body>
  <header><nav>Home &middot; Recipes &middot; About</nav></header>
  <aside class="ad">Buy our new grinder!</aside>
  <main>
    <article>
      <h1>How&nbsp;to brew filter coffee</h1>
      <p>Start with <strong>fresh beans</strong> ground medium-coarse.</p>
      <ul>
        <li>Use a 1:16 ratio.</li>
        <li>Bloom for 30&nbsp;seconds.</li>
      </ul>
      <p class="hidden">Secret affiliate link block.</p>
      <div aria-hidden="true">Hidden cookie banner copy.</div>
    </article>
  </main>
  <footer>&copy; 2026 Coffee Co. Privacy. Terms.</footer>
</body>
</html>

Es weist die vier klassischen Probleme auf: ein Script- und ein Style-Tag, Layout-Chrome (<header>, <nav>, <footer>, eine Anzeige <aside>), ein geschützte Leerzeichen im Text und zwei versteckte Blöcke (.hidden und [aria-hidden="true"]). Wenn eine Bibliothek dies sauber handhabt, wird sie auch das meiste bewältigen, was dir in der Praxis begegnet.

BeautifulSoup ist aus gutem Grund der Standard: Die API ist klein, die Fehlerquellen sind offensichtlich, und dieselben vier Schritte decken fast jede Aufgabe zum Extrahieren von Text aus HTML in Python ab.

Installieren Sie die Grundlagen:

pip install beautifulsoup4 lxml requests

Wir binden lxml als Parser-Backend ein. Das 'lxml' Backend gilt allgemein als schneller und strenger als das der Standardbibliothek html.parser, wobei der genaue Vorsprung von der Eingabegröße und der Dokumentstruktur abhängt; führen Sie bei Bedarf einen Benchmark mit Ihren eigenen Daten durch.

Schritt 1: Parsen Sie mit einem echten Parser. Führen Sie niemals Regex auf vollständigem HTML aus. Übergeben Sie das Markup zunächst an BeautifulSoup.

import requests
from bs4 import BeautifulSoup

resp = requests.get("https://example.com/coffee", timeout=20.0)
resp.raise_for_status()
soup = BeautifulSoup(resp.text, "lxml")

Schritt 2: Entfernen Sie offensichtlichen Ballast. Skripte und Stylesheets sind reiner Ballast für die Textextraktion. Entfernen Sie diese vor allem anderen, da ihr Inhalt sonst direkt in Ihre Ausgabe gelangt.

for tag in soup(["script", "style", "noscript"]):
    tag.decompose()

Verwenden Sie decompose() anstelle von extract() oder unwrap() , wenn du den Tag und seine untergeordneten Elemente entfernen möchtest. extract() entfernt den Knoten, aber du behältst weiterhin eine Referenz; unwrap() behält den Inhalt bei. Für Störsignale decompose() ist das, was du willst.

Schritt 3: Text extrahieren. get_text() flacht das verbleibende DOM zu einer einzigen Zeichenkette ab. Die beiden wichtigen Argumente sind separator und strip. Ohne Trennzeichen fügt BeautifulSoup benachbarte Inline-Elemente zusammen, sodass <strong>fresh</strong>beans zu freshbeans. Übergebe ein Leerzeichen (oder einen Zeilenumbruch), um Wörter voneinander zu trennen, und strip=True um Leerzeichen pro Knoten zu entfernen.

text = soup.get_text(separator=" ", strip=True)

Schritt 4: Leichte Bereinigung. Zu diesem Zeitpunkt haben Sie reinen Text, der noch vereinzelte Leerzeichen, geschützte Leerzeichen und möglicherweise mehrere Leerzeilen enthält. Überlassen Sie die Normalisierung einem speziellen Hilfsmodul (siehe den Abschnitt zur Normalisierung weiter unten) und konzentrieren Sie sich in diesem Schritt auf die Extraktion.

Die Ausführung der vier Schritte auf unserem Beispiel ergibt etwa Folgendes:

Home · Recipes · About Buy our new grinder! How to brew filter coffee Start with fresh beans ground medium-coarse. Use a 1:16 ratio. Bloom for 30 seconds. Secret affiliate link block. Hidden cookie banner copy. © 2026 Coffee Co. Privacy. Terms.

Die Skripte und Stile sind verschwunden, aber Layout, Anzeigen und versteckte Inhalte schleichen sich immer noch ein. Das ist das Problem, das die nächsten Abschnitte lösen.

Wenn Sie die Benutzerfreundlichkeit von BeautifulSoup nicht benötigen und stattdessen auf Geschwindigkeit setzen möchten, lxml.html ist html-text ist eine starke Kombination. lxml liefert dir den geparsten Baum; html-text liefert dir daraus gut normalisierten Text, ohne dass du einen eigenen Walker schreiben musst.

pip install lxml html-text

Eine minimale lxml.html-only-Version derselben Extraktion sieht so aus:

import lxml.html

tree = lxml.html.fromstring(html_source)
for tag in tree.xpath("//script | //style | //noscript"):
    tag.drop_tree()
text = tree.text_content()

text_content() durchläuft das DOM und verkettet Textknoten, fügt jedoch keine Trennzeichen zwischen Block-Level-Elementen ein. Überschriften, Absätze und Listenelemente werden dadurch miteinander verkettet. Genau diese Lücke html-text .

import html_text

text = html_text.extract_text(html_source)

Intern html-text wendet lxml, wendet einige Heuristiken in Bezug auf versteckten Inhalt an (es prüft gängige Muster wie display:none, aria-hiddenund gängige Klassennamen) und fügt Leerzeichen dort ein, wo Block-Level-Elemente visuell Umbrüche erzeugen würden. Die Ausgabe kommt dem, was ein Benutzer in einem Browser sieht, viel näher als rohes text_content().

Es lohnt sich, ehrlich über die Grenzen zu sprechen. html-textDie Sichtbarkeitsheuristiken von sind musterbasiert und nicht browserbasiert. Inline-Stile, die über CSS in einem externen Stylesheet festgelegt werden, per JavaScript angewendete hidden oder A/B-Test-Schalter sind für einen statischen Parser unsichtbar. Wenn Sie tatsächlich gerenderte Sichtbarkeit benötigen, benötigen Sie einen Headless-Browser, auf den wir später eingehen.

html-text isoliert den Hauptartikel zudem nicht von sich aus. Es gibt die Navigation und die Fußzeile problemlos aus, wenn Sie ihm die gesamte Seite übergeben. Kombinieren Sie es mit einem <main> oder <article> Selektor (tree.cssselect('main')[0]), wenn Sie eine Ausgabe nur des Body-Teils wünschen. Diese Kombination – lxml für die Auswahl plus html-text für den Text-Dump – ist eine der saubersten Methoden, um in Python Text aus HTML in großem Umfang zu extrahieren.

Alle paar Monate fragt jemand: „Warum kann ich nicht einfach re.sub('<[^>]+>', '', html)?“ und alle paar Monate lautet die Antwort gleich: weil HTML verschachtelt, fehlerhaft und voller Sonderfälle ist, die reguläre Ausdrücke nicht abbilden können. Die klassischen Gegenbeispiele sind nicht geschlossene Tags, Kommentare mit > , CDATA-Blöcke und Attribute, die spitze Klammern in Anführungszeichen enthalten. Es gibt auch eine berühmte Stack-Overflow-Antwort zu diesem Thema, die ein Schmunzeln wert ist.

Das richtige Vorgehen ist: mit einem echten Parser parsen und dann den resultierenden Klartext mit Regex aufbereiten. Nachdem BeautifulSoup oder html-text einen String geliefert hat, eignet sich Regex gut für Aufgaben wie:

import re
import unicodedata

text = unicodedata.normalize("NFKC", text)
text = text.replace("\u00a0", " ")          # NBSP -> space
text = re.sub(r"[\u2018\u2019]", "'", text) # smart single quotes
text = re.sub(r"[\u201c\u201d]", '"', text) # smart double quotes
text = re.sub(r"[ \t]+", " ", text)         # collapse runs of spaces
text = re.sub(r"\n{3,}", "\n\n", text)      # collapse blank-line runs

Zu vermeiden: das Entfernen von Tags mit regulären Ausdrücken, das Extrahieren von Attributwerten aus rohem HTML mit regulären Ausdrücken und das Aufteilen nach < und > , um „den Text zu erhalten“. Das funktioniert in einer handgeschriebenen Demo, versagt aber in der Produktion. Wenn du jemals in Versuchung gerätst, schreibe zuerst die parserbasierte Version und greife erst dann auf Regex zurück, wenn der bereits flache String vorliegt, den sie erzeugt.

Die Ausgabe, die wir aus dem BeautifulSoup-Walkthrough erhielten, enthielt immer noch die Navigation, einen Anzeigenblock, einen versteckten Affiliate-Absatz, ein aria-hidden Cookie-Banner und die Fußzeile. Nichts davon ist für die Indizierung oder Analyse nützlich. Das Bereinigen dieser Elemente vor der Extraktion ist der größte Qualitätsgewinn, den du erzielen kannst, wenn du mit Python Text aus HTML extrahierst.

Das Muster lautet: Parsen, Skripte und Stile entfernen, Layout-Chrome entfernen, versteckte Inhalte entfernen, dann get_text().

from bs4 import BeautifulSoup

NOISE_TAGS = ["script", "style", "noscript", "template", "svg"]
CHROME_SELECTOR = (
    "header, footer, nav, aside, "
    ".cookie-banner, .cookie, .consent, .gdpr, "
    ".ad, .ads, .advert, .promo, .newsletter, "
    ".social-share, .related, .breadcrumbs"
)
HIDDEN_SELECTOR = (
    ".hidden, .visually-hidden, .sr-only, "
    "[aria-hidden='true'], [hidden], "
    "[style*='display:none'], [style*='visibility:hidden']"
)

def clean(soup):
    for tag in soup(NOISE_TAGS):
        tag.decompose()
    for tag in soup.select(CHROME_SELECTOR):
        tag.decompose()
    for tag in soup.select(HIDDEN_SELECTOR):
        tag.decompose()
    return soup

Die Reihenfolge der Schritte ist entscheidend. Entfernen Sie zuerst Skripte und Styles, da diese oft in den Elementen enthalten sind, die Sie abfragen wollen, und wenn Sie sie zuerst entfernen, bleiben Ihre Selektoren zuverlässig. Entfernen Sie dann Layout-Chrome nach Tag-Namen. Selektoren nach Klassennamen kommen als Nächstes, da sie der heikle Teil sind: Jede Website benennt Dinge anders, und Sie müssen diese Liste je nach Quelle anpassen.

Warum decompose() und nicht extract()? decompose() löscht den Knoten und alle seine Kinder aus dem Baum und gibt ihre Referenzen frei. extract() entfernt den Knoten, gibt ihn aber zurück, was nützlich ist, wenn du einen Knoten an einen anderen Ort verschieben möchtest, nicht jedoch, wenn du Datenmüll löschst. Zur Bereinigung immer decompose().

Nach dem Ausführen clean(soup) auf unserem Beispiel ausführen und anschließend soup.get_text(separator="\n", strip=True)erhalten Sie etwas, das dem nahekommt, was ein Leser tatsächlich sieht:

How to brew filter coffee
Start with fresh beans ground medium-coarse.
Use a 1:16 ratio.
Bloom for 30 seconds.

Das ist das Ziel: die Überschriften und Absätze, die für den Menschen wichtig sind, wobei alle Standardtextteile entfernt wurden. Betrachten Sie die oben genannten Chrome- und Hidden-Selektoren als Startpaket, nicht als fertige Liste; jede Domain, die Sie scrapen, wird ein oder zwei neue Klassen hinzufügen, die Sie entfernen müssen.

Das Entfernen von Chrome funktioniert, aber der sauberere Ansatz bei gut strukturiertem Markup besteht darin, den Hauptinhalt direkt zu extrahieren. Modernes HTML bietet dir drei gute Ansatzpunkte:

main = (
    soup.select_one("main")
    or soup.select_one("article")
    or soup.select_one("[role='main']")
)
if main is None:
    main = soup.body or soup
text = main.get_text(separator="\n", strip=True)

Diese Fallback-Leiter, <main>, <article>, role="main", dann <body>, deckt die meisten Content-Websites ab. Wenn du den resultierenden Teilbaum zusätzlich mit den Chrome- und Hidden-Selektoren aus dem vorherigen Abschnitt bereinigst, erhältst du in der Regel reinen Body-Text, ohne für jede Website eigene Regeln schreiben zu müssen.

Wenn das Markup schlecht ist (man denke an alte CMS-Vorlagen ohne semantische Tags), greifen Sie auf readability-lxml oder trafilatura. Beide wenden Heuristiken zur Textdichte an: Sie bewerten jeden Block anhand des Verhältnisses von Text zu Markup und der Linkdichte und geben den Bereich mit der höchsten Punktzahl als Hauptartikel zurück. Keines der beiden ist perfekt; gelegentlich greifen sie einen Kommentarbereich auf oder übersehen einen Sidebar-Callout. Behandeln Sie sie als Fallback, wenn strukturelle Selektoren versagen, nicht als Standard.

Die Rohausgabe von get_text() ist selten „sauber“. Sie werden geschützte Leerzeichen (\u00a0), wo Sie echte Leerzeichen erwartet hätten, \r\n Zeilenenden auf unter Windows erstellten Seiten, drei oder vier Leerzeilen aus großzügigen CMS-Vorlagen und gelegentlich halbbreite Katakana-Zeichen oder Ligaturen dank Unicode. Ein kleiner, spezieller Normalisierer behebt all dies auf einen Schlag und spart dir später Zeit beim Debuggen.

import re
import unicodedata

def normalize_text(text: str) -> str:
    # 1. Unicode-canonical form
    text = unicodedata.normalize("NFKC", text)
    # 2. NBSP and other exotic spaces -> regular space
    text = text.replace("\u00a0", " ").replace("\u200b", "")
    # 3. Normalize line endings
    text = text.replace("\r\n", "\n").replace("\r", "\n")
    # 4. Strip per-line whitespace
    lines = [line.strip() for line in text.split("\n")]
    # 5. Collapse internal runs of spaces and tabs
    lines = [re.sub(r"[ \t]+", " ", line) for line in lines]
    # 6. Collapse runs of blank lines down to one blank line
    out, blank_run = [], 0
    for line in lines:
        if line == "":
            blank_run += 1
            if blank_run <= 1:
                out.append(line)
        else:
            blank_run = 0
            out.append(line)
    return "\n".join(out).strip()

Ein paar Anmerkungen dazu, was dir die einzelnen Schritte bringen. unicodedata.normalize("NFKC", ...) faltet Kompatibilitätszeichen zu ihren kanonischen Entsprechungen zusammen, sodass das Zeichen mit voller Breite Ａ zu einem normalen A und Ligaturen wie fi zu fi. Die Python-Dokumentation zum Modul `unicodedata` beschreibt detailliert, was die einzelnen Formen bewirken.

Das frühzeitige Entfernen von NBSP ist wichtig, da re.sub(r"\s+", ...) in \u00a0 in modernem Python, aber nachgelagerte Tokenizer und Suchindexierer tun dies oft nicht. Die Normalisierung von Zeilenenden verhindert, dass ein einzelnes \r JSONL-Dateien nicht mehr zerreißt. Das Zusammenfassen von Leerzeichenfolgen bewahrt Absatzumbrüche, ohne seitenweise Leerzeilen zu erzeugen.

Führen Sie diesen Helfer einmal am Ende Ihrer Pipeline aus, niemals innerhalb der Per-Tag-Schleife, und Sie erhalten Text, den nachgelagerte Tools tatsächlich verarbeiten können.

Eine einzelne flache Zeichenkette eignet sich gut für die Suche und grobe Analyse, ist jedoch ungeeignet für das Chunking bei der Informationsgewinnung (RAG), die Zusammenfassung und alles, was auf Hierarchien Wert legt. Wenn es für Ihren nachgelagerten Verbraucher von Vorteil ist, zu wissen, was eine Überschrift und was Fließtext ist, geben Sie typisierte Blöcke anstelle einer einzigen großen Zeichenkette aus.

BLOCK_TAGS = {"h1", "h2", "h3", "h4", "h5", "h6", "p", "li", "blockquote", "td", "pre"}

def extract_blocks(soup):
    blocks = []
    for el in soup.find_all(list(BLOCK_TAGS)):
        text = el.get_text(separator=" ", strip=True)
        if not text:
            continue
        kind = "heading" if el.name.startswith("h") else "body"
        blocks.append({
            "kind": kind,
            "tag": el.name,
            "text": text,
        })
    return blocks

In unserem Beispielartikel ergibt dies etwa Folgendes:

[
  {"kind": "heading", "tag": "h1", "text": "How to brew filter coffee"},
  {"kind": "body",    "tag": "p",  "text": "Start with fresh beans ground medium-coarse."},
  {"kind": "body",    "tag": "li", "text": "Use a 1:16 ratio."},
  {"kind": "body",    "tag": "li", "text": "Bloom for 30 seconds."},
]

Warum sollte man sich die Mühe machen? Drei Gründe. Erstens kann ein LLM-Chunker Überschriften mit den darauf folgenden Absätzen zusammenhalten, anstatt sie zu zerschneiden. Zweitens können Analyseabfragen Überschriften getrennt vom Fließtext zählen, was für Inhaltsaudits wichtig ist. Drittens können Sie Überschriften zu einer Gliederung zusammenfassen (# How to brew filter coffee) zusammenfassen und den Fließtext darunter belassen, was Ihnen kostenlos eine Markdown-ähnliche Ausgabe liefert.

Wenn du die Reihenfolge und Verschachtelung beibehalten musst (eine Überschrift und ihre untergeordneten Absätze als Abschnitt), wiederhole den Vorgang mit soup.descendants und gruppiere Blöcke jedes Mal, wenn du auf ein Überschriften-Tag stößt. Die Struktur ist kostengünstig zu erhalten, aber teuer, später wiederherzustellen, also erfaße sie einmalig bei der Extraktion.

Zeit, alles zusammenzufügen. Das folgende Skript crawlt einen paginierten Abschnitt einer Website, extrahiert sauberen Text pro Seite, normalisiert ihn und schreibt einen JSONL-Datensatz pro Seite sowie eine .txt Datei. Es verwendet ein einziges requests.Session, folgt dem Next Paginierungslink und stoppt bei einem konfigurierbaren max_pages.

import json
import re
import time
import unicodedata
from pathlib import Path
from urllib.parse import urljoin

import requests
from bs4 import BeautifulSoup

HEADERS = {
    "User-Agent": "text-extractor/1.0 (+contact@example.com)",
    "Accept": "text/html,application/xhtml+xml",
}
NOISE_TAGS = ["script", "style", "noscript", "template", "svg"]
CHROME = "header, footer, nav, aside, .cookie-banner, .ad, .related, .newsletter"
HIDDEN = ".hidden, [aria-hidden='true'], [hidden]"

def fetch_soup(session, url):
    resp = session.get(url, headers=HEADERS, timeout=20.0)
    resp.raise_for_status()
    if resp.encoding is None or resp.encoding.lower() == "iso-8859-1":
        resp.encoding = resp.apparent_encoding
    return BeautifulSoup(resp.text, "lxml")

def clean(soup):
    for tag in soup(NOISE_TAGS):
        tag.decompose()
    for tag in soup.select(CHROME):
        tag.decompose()
    for tag in soup.select(HIDDEN):
        tag.decompose()
    return soup

def main_subtree(soup):
    return (
        soup.select_one("main")
        or soup.select_one("article")
        or soup.select_one("[role='main']")
        or soup.body
        or soup
    )

def normalize_text(text: str) -> str:
    text = unicodedata.normalize("NFKC", text)
    text = text.replace("\u00a0", " ").replace("\u200b", "")
    text = text.replace("\r\n", "\n").replace("\r", "\n")
    text = "\n".join(line.strip() for line in text.split("\n"))
    text = re.sub(r"[ \t]+", " ", text)
    text = re.sub(r"\n{3,}", "\n\n", text)
    return text.strip()

def extract(soup):
    cleaned = clean(soup)
    body = main_subtree(cleaned)
    title = soup.title.get_text(strip=True) if soup.title else ""
    raw = body.get_text(separator="\n", strip=True)
    return title, normalize_text(raw)

def crawl(start_url: str, out_dir: Path, max_pages: int = 25):
    out_dir.mkdir(parents=True, exist_ok=True)
    jsonl_path = out_dir / "pages.jsonl"
    session = requests.Session()
    url, count = start_url, 0
    with jsonl_path.open("w", encoding="utf-8") as out:
        while url and count < max_pages:
            try:
                soup = fetch_soup(session, url)
            except requests.RequestException as exc:
                print(f"[skip] {url}: {exc}")
                break
            title, text = extract(soup)
            record = {"url": url, "title": title, "text": text}
            out.write(json.dumps(record, ensure_ascii=False) + "\n")
            (out_dir / f"page-{count:03d}.txt").write_text(text, encoding="utf-8")
            next_link = soup.select_one("ul.pager li.next a")
            url = urljoin(url, next_link["href"]) if next_link else None
            count += 1
            time.sleep(1.0)  # be polite
    return count

if __name__ == "__main__":
    pages = crawl(
        start_url="https://example.com/blog/",
        out_dir=Path("out"),
        max_pages=10,
    )
    print(f"Saved {pages} pages")

Die Teile sind bewusst klein gehalten. Ersetze fetch_soup durch einen Playwright-Fetcher aus, wenn Sie auf JavaScript-gerenderte Seiten stoßen. Ersetzen Sie den Paginierungsselektor durch das, was Ihre Ziel-Website verwendet. Ersetzen Sie den JSONL-Writer durch einen SQLite-Insert, wenn Sie einen abfragbaren Speicher wünschen. Das Muster – parsen, bereinigen, extrahieren, normalisieren, speichern – bleibt identisch.

Zwei kleine Details, die es zu beachten gilt. Der fetch_soup() Helper wendet ein 20-Sekunden-Timeout für Anfragen an und greift auf apparent_encoding , wenn der Server den Standardwert iso-8859-1. Beides lässt sich jetzt kostengünstig hinzufügen, ist aber später mühsam nachzurüsten. Die time.sleep(1.0) Zwischen den Seiten ist das Mindestmaß an höflichem Verhalten; für ernsthaftes Crawling siehe den Abschnitt zur Skalierung weiter unten.

Passen Sie das Speicherformat an den Verbraucher an, nicht an das, was Sie zuerst eingegeben haben.

• JSONL (ein JSON-Objekt pro Zeile) ist der Standard für Scraping-Pipelines. Es ist streamfähig, nur für Anfügungen geeignet, leicht zu überprüfen head -n 1 pages.jsonl | jq .und tolerant gegenüber sich ändernden Datensatzformen. Verwenden Sie es, wenn Datensätze mehrere Felder oder eine verschachtelte Struktur haben.
• CSV ist die richtige Wahl, wenn nachgelagerte Verbraucher Tabellenkalkulationen, Pandas oder BI-Tools sind. Halten Sie sich an ein flaches Schema mit vorhersehbaren Spalten und schreiben Sie mit csv.DictWriter , damit Sie nichts manuell in Anführungszeichen setzen müssen.
• Reiner Text (.txt) pro Seite ist ideal für NLP, Suchindexierung und LLM-Erfassung. Eine Datei pro Dokument sorgt für Git-Kompatibilität und ermöglicht die parallele Verarbeitung von Seiten ohne Datensatz-Framing.
• SQLite oder DuckDB sind die richtige Wahl, sobald du Ad-hoc-Abfragen („Wie viele Seiten erwähnen Espresso?“) oder Verknüpfungen mit anderen Tabellen durchführen möchtest. Beide werden als Ein-Datei-Datenbank ohne jegliche Einrichtung bereitgestellt.

In der Praxis schreibt die oben beschriebene Pipeline JSONL und seitenweise .txt gleichzeitig. JSONL ist Ihr Metadatenindex; die .txt Dateien sind das, was Sie der nächsten Stufe zuführen.

Fehler bei der Kodierung sind der zweithäufigste Grund, warum eine Python-Pipeline zum Extrahieren von Text aus HTML unbrauchbare Daten liefert. Die klassischen Symptome sind é , dass an Stellen, an denen Sie é, Ersatzzeichen (�) mitten in Absätzen oder das gefürchtete UnicodeDecodeError auf resp.text.

Die Ursache ist fast immer, dass requests standardmäßig auf iso-8859-1 , da in der Antwort der Content-Type Header fehlte. Die requests Dokumentation weist darauf hin: Wenn keine Kodierung angegeben ist, iso-8859-1 wird angenommen. Überschreiben Sie dies:

resp = session.get(url, timeout=20.0)
if resp.encoding is None or resp.encoding.lower() == "iso-8859-1":
    resp.encoding = resp.apparent_encoding  # chardet-style sniff
html = resp.text

Bei Rohdaten explizit dekodieren und errors="replace" , um die Pipeline bei fehlerhafter Eingabe am Laufen zu halten:

html = resp.content.decode("utf-8", errors="replace")

Dann gibt es noch fehlerhaftes Markup selbst. lxml ist streng; es überspringt Teile stark fehlerhafter Eingaben stillschweigend oder gleicht sie neu aus. BeautifulSoup mit der Standardeinstellung html.parser ist nachsichtiger, aber langsamer. Wenn Ihre Daten eine Mischung aus sauberem und fehlerhaftem HTML sind, versuchen Sie BeautifulSoup(html, "html5lib"), das das nachsichtigste Backend ist und denselben Parsing-Algorithmus verwendet wie Browser. Der Nachteil ist die Geschwindigkeit: html5lib ist bei großen Dokumenten deutlich langsamer als lxml bei großen Dokumenten, also reservieren Sie es für die fehlerhafte Minderheit.

Früher oder später wirst du eine Seite abrufen, resp.textund eine leere <div id="root"> , wo eigentlich der Inhalt sein sollte. Die Website rendert ihren Inhalt clientseitig mit React, Vue oder ähnlichen Technologien, und requests führt kein JavaScript aus. Das lässt sich durch noch so geschickte Extraktion nicht beheben.

Drei realistische Optionen:

1. Suchen Sie nach einem vorgerenderten Inhalt oder einem API-Endpunkt. Viele SPAs werden über eine JSON-API geladen, die der Browser beim Laden aufruft. Öffnen Sie die DevTools, beobachten Sie den Tab „Netzwerk“, und Sie werden oft einen strukturierten Endpunkt finden, der genau das zurückgibt, was Sie brauchen, ganz ohne HTML-Parsing.
2. Führen Sie einen Headless-Browser aus. Playwright, Pyppeteer, und Selenium alle starten echte Browser-Engines (Chromium, Firefox, WebKit), die JavaScript ausführen. Der Preis dafür ist Komplexität und Ressourcenverbrauch: Jede Seite kostet Sie einen Tab in einem echten Browser, was um ein Vielfaches teurer ist als ein requests Aufruf.
3. Verwenden Sie eine Scraping-API, die gerenderten HTML-Code zurückgibt. Dienste, die das Headless-Rendering für Sie übernehmen, akzeptieren eine URL und geben das endgültige DOM als String zurück, der direkt in die oben beschriebene BeautifulSoup-Pipeline eingefügt werden kann. Sie geben etwas Kontrolle über die Browsereinstellungen ab, gewinnen dafür aber eine einfachere Infrastruktur und einen konsistenten Durchsatz.

Ein minimaler Playwright-Fetcher sieht so aus:

from playwright.sync_api import sync_playwright

def fetch_rendered(url: str) -> str:
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        page.goto(url, wait_until="networkidle", timeout=30_000)
        html = page.content()
        browser.close()
    return html

Binden Sie das in den fetch_soup Schritt des Miniprojekts ein (das zurückgegebene html mit BeautifulSoup) und der Rest der Pipeline bleibt unverändert. Der Schleife aus Parsen, Bereinigen, Extrahieren und Normalisieren ist es egal, woher das HTML stammt.

Sobald Ihre Extraktion auf einer Handvoll Seiten funktioniert, verlagert sich der Engpass vom Parsen zum Abrufen. Websites begrenzen Ihre Zugriffe, IPs von Rechenzentren werden blockiert, CAPTCHAs erscheinen, und derselbe Selektor, der gestern noch funktionierte, liefert heute keine Ergebnisse, weil die Seite Ihren Client identifiziert.

Eine praktische Checkliste zur Zuverlässigkeit für die Abrufebene:

• Beachten robots.txt und die Nutzungsbedingungen der Website. urllib.robotparser liest sie für dich.
• Legen Sie realistische Timeouts fest (15–30 Sekunden für Verbindung + Lesen), damit eine hängende Verbindung nicht den gesamten Lauf blockieren kann.
• Versuche es erneut mit exponentiellem Backoff bei 429, 502, 503 und 504. tenacity oder urllib3.util.Retry behandeln Sie dies mit ein paar Zeilen in der Konfiguration.
• Verwende realistische Header. Ein User-Agent , der Ihren Bot identifiziert, sowie ein Accept und Accept-Language Header umgeht die faulsten Erkennungsregeln.
• Drosselung pro Host. Ein einzelner requests.Session mit einer time.sleep zwischen den Anfragen ist das Minimum; für gleichzeitiges Crawling ist ein Token-Bucket pro Host erforderlich.
• Wechseln Sie die IPs, wenn Sie große Datenmengen verarbeiten. Residential-Proxys sehen aus wie gewöhnlicher Nutzerverkehr; Rechenzentrums-IPs werden auf vielen großen Websites standardmäßig als verdächtig markiert.

Wenn Sie Ihre Entwicklungszeit nicht damit verbringen möchten, all das intern zu verwalten, kann eine gehostete Fetch-API die Proxy-Rotation, das Lösen von CAPTCHAs und die Wiederholungslogik hinter einem einzigen Endpunkt übernehmen, während Sie den BeautifulSoup- oder lxml Parsing-Code unverändert. Das ist das Modell, auf dem WebScrapingAPI basiert: Sie senden die URL, erhalten das gerenderte HTML (oder strukturiertes JSON) zurück, und Ihre Extraktionspipeline bleibt Python.

Egal, für welchen Weg Sie sich entscheiden: Trennen Sie die Aufgaben klar voneinander. Halten Sie den Fetcher in einem Modul und den Extractor in einem anderen. Dann können Sie requests Playwright gegen eine gehostete API austauschen, ohne den Parsing-Code anzurühren.

Sprachen ändern sich, Bibliotheken ändern sich, aber die Denkweise bei der Extraktion bleibt gleich. Die gleiche Schleife aus Parsen, Bereinigen, Extrahieren und Normalisieren lässt sich auf verschiedene Stacks übertragen. Hier ist das Äquivalent zum BeautifulSoup-Leitfaden in drei anderen Ökosystemen – nützlich, wenn du in einem mehrsprachigen Team arbeitest oder dich gerade entscheidest, auf welche Sprache du standardisieren möchtest.

Ruby mit Nokogiri. Nokogiri ist der Standard-HTML-Parser in der Ruby-Welt und spielt dieselbe Rolle wie BeautifulSoup oder lxml in Python.

require "nokogiri"
require "open-uri"

doc = Nokogiri::HTML(URI.open("https://example.com/coffee"))
doc.search("script, style, header, footer, nav, aside").each(&:remove)
text = doc.text.gsub(/\s+/, " ").strip
puts text

JavaScript mit Cheerio. Cheerio implementiert eine jQuery-ähnliche API auf Basis eines schnellen HTML-Parsers. jsdom ist die schwerfälligere Alternative, wenn Sie auch DOM-APIs und CSS-fähiges Rendering benötigen.

import * as cheerio from "cheerio";

const html = await (await fetch("https://example.com/coffee")).text();
const $ = cheerio.load(html);
$("script, style, header, footer, nav, aside").remove();
const text = $("main, article, body").first().text().replace(/\s+/g, " ").trim();
console.log(text);

C# mit HtmlAgilityPack. Das Muster ist dasselbe; die API ist ausführlicher.

using HtmlAgilityPack;

var web = new HtmlWeb();
var doc = web.Load("https://example.com/coffee");
var junk = doc.DocumentNode.SelectNodes("//script|//style|//header|//footer|//nav|//aside");
if (junk != null) foreach (var n in junk) n.Remove();
var text = System.Text.RegularExpressions.Regex.Replace(
    doc.DocumentNode.InnerText, @"\s+", " ").Trim();
Console.WriteLine(text);

Jedes dieser Snippets folgt denselben vier Schritten wie die Python-Version: Parsen, offensichtlichen Ballast (Skripte, Styles, Chrome) entfernen, Text aus dem verbleibenden Baum extrahieren und Leerzeichen zusammenfassen. Wenn man die Schleife verinnerlicht, wird der Wechsel der Sprache zu einer syntaktischen Übung und nicht zu einem Umdenken.

Wenn Sie mit Python Text aus HTML extrahieren, ist die Ausgabe beim ersten Durchlauf selten perfekt. Diese Tabelle ordnet die tatsächlich auftretenden Symptome den Lösungen zu, die tatsächlich funktionieren.

Arbeite von oben nach unten: Behebe zuerst Skripte und Stile, dann Chrome, dann die Kodierung. Die überwiegende Mehrheit der Fehler vom Typ „Meine Extraktion funktioniert nicht“ liegt in einer der ersten vier Zeilen.

• Der zuverlässige Weg, um Text aus HTML in Python zu extrahieren, ist eine vierstufige Schleife: mit einem echten Parser analysieren, offensichtlichen Rauschen und Website-Chrome entfernen, Text aus dem Verbleibenden extrahieren und Leerzeichen sowie Unicode normalisieren.
• Beginnen Sie für fast alles mit BeautifulSoup. Wechseln Sie zu lxml.html plus html-text , wenn du Geschwindigkeit oder eine sauberere Standardbehandlung von Leerzeichen benötigst. Verwende Parsel für strukturierte Felder, nicht für die Bereinigung von reinem Text.
• Führen Sie niemals reguläre Ausdrücke auf dem vollständigen HTML-Code aus. Parsen Sie zuerst und verwenden Sie dann reguläre Ausdrücke, um die resultierende reine Zeichenkette zu bereinigen (NBSP, Smart Quotes, zusammengefasste Leerzeichen).
• Isolieren Sie den Hauptartikel mit <main>, <article>oder [role="main"] vor dem Extrahieren. Greife nur dann auf Heuristiken im Readability-Stil zurück, wenn das Markup keine semantischen Anknüpfungspunkte bietet.
• requests JavaScript kann nicht ausgeführt werden. Wechsle bei clientseitig gerenderten Seiten den Fetcher zu einem Headless-Browser oder einer Rendering-API; der Parsing-Code bleibt derselbe.
• Speichern Sie Metadaten als JSONL und die Seiteninhalte als .txt. Diese Kombination liefert Ihnen einen streambaren Index sowie pipeline-fähigen Text, ohne dass Sie sich zu früh auf eine Datenbank festlegen müssen.

• Python BeautifulSoup Web-Scraper
• Daten-Parsing

BeautifulSoup ist fehlertolerant und anfängerfreundlich; lxml.html ist schnell und streng mit vollständiger XPath-Unterstützung; html-text baut darauf auf lxml , um sauberen, lesbaren Text mit sinnvollen Leerzeichen zu erzeugen; Parsel ist selektororientiert, um strukturierte Felder wie Preise oder Autoren zu extrahieren. Verschiedene Ausprägungen desselben Problems: Wählen Sie BeautifulSoup, es sei denn, eines der anderen Tools verfügt über eine Funktion, die Sie speziell benötigen.

Wählen Sie zuerst den Hauptunterbaum aus: versuchen Sie soup.select_one("main"), dann "article", dann "[role='main']"und greife auf soup.body. Entferne innerhalb dieses Teilbaums Anzeigen, Blöcke mit verwandten Beiträgen, Share-Widgets und alle versteckten Elemente per CSS-Selektor. Wenn das Markup keine semantischen Anker enthält, können Bibliotheken wie readability-lxml oder trafilatura Blöcke nach Textdichte bewerten und den besten Kandidaten zurückgeben.

Das bedeutet, dass Sie get_text() vor dem Entfernen <script> und <style> . Der Parser behandelt deren Inhalte als gewöhnliche Textknoten. Durchlaufe diese Tags und rufe .decompose() vor der Extraktion für jeden einzelnen auf. Füge <noscript> und <template> zur gleichen Liste hinzu, während Sie dabei sind; beide können Markup oder Fallback-Text in Ihre Ausgabe einfließen lassen.

Rufen Sie entweder die zugrunde liegende API ab, die die Seite verwendet (siehe DevTools-Registerkarte „Netzwerk“), oder rendern Sie die Seite mit einem headless Browser wie Playwright, Selenium oder Pyppeteer. Sobald Sie die gerenderte HTML-Zeichenkette haben, verläuft der Rest Ihrer Extraktionspipeline identisch. Eine gehostete Rendering-API funktioniert auf die gleiche Weise, wenn Sie keine Browser selbst ausführen möchten.

Nicht als Parser. Regex kann verschachtelte Tags, nicht geschlossene Elemente, Kommentare mit spitzen Klammern oder CDATA nicht zuverlässig verarbeiten. Verwenden Sie zunächst einen echten HTML-Parser, um das Dokument zu vereinfachen, und wenden Sie dann Regex auf die resultierende reine Zeichenkette an, um kleinere Aufgaben wie das Zusammenziehen von Leerzeichen, die Normalisierung von Anführungszeichen oder das Ersetzen von geschützten Leerzeichen zu erledigen.

Der Grund, warum das Extrahieren von Text aus HTML in Python schwieriger erscheint, als es sein sollte, ist, dass die meisten Tutorials bei soup.get_text(). Der eigentliche Arbeitsablauf umfasst vier Schritte: Parsen, Bereinigen, Extrahieren, Normalisieren sowie einen fünften Schritt (Speichern), sobald du ihn in eine Pipeline einbindest. Verinnerliche diesen Ablauf, und die Wahl der Bibliothek wird zur Nebensache: BeautifulSoup für die meisten Aufgaben, lxml.html plus html-text wenn Sie Geschwindigkeit und sauberere Standardeinstellungen benötigen, Parsel, wenn Sie strukturierte Felder wünschen, und einen Headless-Browser, wenn JavaScript im Weg steht.

Von hier aus sind die logischen nächsten Schritte das Crawlen in großem Maßstab (Paginierung, höfliche Drosselung, Deduplizierung), sich mit Selektoren und XPath vertraut zu machen und zu entscheiden, wann strukturbewusste Parser wie Parsel oder Lesbarkeitsheuristiken eingesetzt werden sollten. Jeder dieser Bereiche ist ein eigenes Kaninchenloch, aber sie alle basieren auf derselben Extraktionsschleife.

Wenn die Abrufebene Sie ausbremst (Blöcke, CAPTCHAs, JS-Rendering), lohnt es sich, WebScrapingAPI als Drop-in-Fetcher auszuprobieren: Senden Sie eine URL, erhalten Sie gerendertes HTML zurück und lassen Sie Ihren Python-Extraktionscode den Rest erledigen. Beginnen Sie einfach mit BeautifulSoup, analysieren Sie, wann es nicht mehr skaliert, und greifen Sie erst dann zu den schwereren Werkzeugen.