Pandas read_html: Extrahieren von HTML-Tabellen in Python

HTML-Tabellen in Python extrahieren mit Pandas read_html()

Pandas, eine unverzichtbare Python-Bibliothek für Datenanalyse und -manipulation, bietet eine praktische Methode namens read_html() zum Extrahieren von HTML-Tabellen in Python. Diese Methode bietet eine einfache und effiziente Möglichkeit, Daten aus HTML-Dokumenten zu laden, selbst wenn diese komplex strukturiert sind.

Verwendung von read_html()

Um read_html() zu verwenden, lädst du zunächst die HTML-Datei oder -URL in eine Variable. Dann rufst du read_html() mit dem HTML-Inhalt als Argument auf. Die Methode gibt eine Liste von DataFrames zurück, wobei jeder DataFrame eine Tabelle aus dem HTML-Dokument darstellt.

import pandas as pd

# HTML-Dokument laden
html = pd.read_html('beispiel.html')

# Liste der extrahierten DataFrames drucken
print(html)

Handhabung unvollständiger oder fehlerhafter HTML-Tabellen

Manchmal können HTML-Tabellen unvollständig oder fehlerhaft sein. Um mit solchen Fällen umzugehen, kannst du die folgenden Argumente in read_html() verwenden:

• header: Gibt die Zeilen an, die als Kopfzeilen verwendet werden sollen.
• index_col: Gibt die Spalte an, die als Indexspalte verwendet werden soll.
• keep_default_na: Fügt fehlende Werte in den extrahierten DataFrames ein.

# Unvollständige Tabelle mit benutzerdefinierten Headern und Index
html = pd.read_html('beispiel.html', header=1, index_col=0, keep_default_na=False)

Verarbeitung extrahierter Tabellen

Sobald du HTML-Tabellen extrahiert hast, kannst du sie wie reguläre DataFrames in Pandas manipulieren. Du kannst sie in verschiedene Formate konvertieren, Daten bereinigen und komplexe Operationen durchführen.

# Extrahierte Tabelle in eine CSV-Datei konvertieren
html[0].to_csv('tabelle.csv', index=False)

# Daten in der Tabelle bereinigen
html[0] = html[0].dropna()

Syntax und Argumente von read_html()

Die Pandas-Funktion read_html() dient zum Extrahieren von Tabellendaten aus HTML. Ihre Syntax lautet wie folgt:

def read_html(io, match=".+", header=None, index_col=None, attrs=None, flavor=None, encoding=None, decimal=".", thousands=None, converters=None, keep_default_na=True, na_values=None, skiprows=None) -> list[DataFrame]

Argumente

Hier sind die wichtigsten Argumente von read_html():

• io: Der Eingabe-Stream oder -String, der die HTML-Tabelle enthält. Kann ein Dateiname (als Zeichenfolge), eine URL oder ein File-ähnliches Objekt sein.
• match: (Optional) Eine reguläre Ausdruckszeichenfolge (Regex), die die Tabellenelemente angibt, die extrahiert werden sollen. Standardmäßig extrahiert read_html() alle Tabellen.
• header: (Optional) Die Zeilennummern, die als Tabellenkopfzeilen verwendet werden sollen. Standardmäßig ist header=0, was bedeutet, dass die erste Zeile als Kopfzeile verwendet wird.

Weitere hilfreiche Argumente

• attrs: (Optional) Ein Wörterbuch mit HTML-Attributen und ihren Werten, um Tabellen zu identifizieren. Beispielsweise {"id": "my-table"}.
• flavor: (Optional) Die HTML-Parsing-Engine. Standardmäßig ist flavor='bs4', was den Beautiful Soup-Parser verwendet.
• converters: (Optional) Ein Wörterbuch, das Spaltennamen Funktionen zuordnet, um die Konvertierung von Spaltenwerten zu ermöglichen.

Tipps

• Wenn deine HTML-Tabelle mehrere Seiten hat, kannst du das Argument skiprows verwenden, um die Anzahl der zu überspringenden Zeilen anzugeben, z. B. skiprows=[1, 2].
• Wenn deine HTML-Tabelle unvollständig oder fehlerhaft ist, kannst du die Argumente na_values und keep_default_na verwenden, um fehlende Werte zu verarbeiten.
• Für die Behandlung komplexer HTML-Strukturen kannst du die Argumente match und attrs verwenden, um Tabellenelemente präzise zu identifizieren.

Behandeln unvollständiger oder fehlerhafter HTML-Tabellen

Wenn die extrahierte HTML-Tabelle unvollständig oder fehlerhaft ist, kannst du bestimmte Argumente und Funktionen von read_html() verwenden, um diese Probleme anzugehen.

Fehlende Werte

Manchmal enthalten HTML-Tabellen leere Zellen oder fehlende Werte. Du kannst das Argument keep_default_na=False verwenden, um diese fehlenden Werte als NaN (Not a Number) zu interpretieren. Dies erleichtert die Verarbeitung der Daten in einem späteren Schritt.

Fehlerhafte HTML

Gelegentlich kannst du auf fehlerhafte HTML-Tabellen stoßen, die zu Parsing-Fehlern führen. Das Argument flavor='lxml' kann in solchen Fällen hilfreich sein. Es aktiviert einen robusteren Parser, der HTML-Fehler besser handhaben kann.

Zu wenig Informationen

In manchen Fällen kann eine HTML-Tabelle nicht genügend Informationen enthalten, um alle Spalten eines Pandas DataFrames zu füllen. Du kannst das Argument attrs verwenden, um zusätzliche Informationen aus den HTML-Tabellenelementen abzurufen.

Beispiel

Betrachte das folgende HTML-Fragment mit einer unvollständigen Tabelle:

<table>
  <thead>
    <tr>
      <th>Name</th>
      <th>Alter</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>John</td>
      <td>30
    </tr>
    <tr>
      <td>Mary</td>
    </tr>
  </tbody>
</table>

Um diese Tabelle zu extrahieren und die fehlenden Werte als NaN zu interpretieren, kannst du den folgenden Code verwenden:

import pandas as pd

html = '''<table>
  <thead>
    <tr>
      <th>Name</th>
      <th>Alter</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>John</td>
      <td>30
    </tr>
    <tr>
      <td>Mary</td>
    </tr>
  </tbody>
</table>'''

df = pd.read_html(html, keep_default_na=False)
print(df)

Ausgabe:

   Name  Alter
0  John   30.0
1  Mary    NaN

Verarbeitung extrahierter Tabellen: Konvertieren in DataFrames und Bereinigen von Daten

Nachdem du HTML-Tabellen mit Pandas read_html() extrahiert hast, musst du sie möglicherweise in DataFrames konvertieren und die Daten aufbereiten, um sie für deine Analyse geeignet zu machen.

Tabellen in DataFrames konvertieren

Um eine extrahierte Tabelle in einen DataFrame zu konvertieren, nutze pd.DataFrame(). Du kannst den header-Parameter angeben, um die Headerzeile der Tabelle zu definieren, oder index_col, um eine Spalte als Index für den DataFrame zu verwenden.

import pandas as pd

tables = pd.read_html('url_zur_HTML_Tabelle')
df = pd.DataFrame(tables[0])

Datenbereinigung

Duplikate entfernen:

Duplikate aus dem DataFrame kannst du mit df.drop_duplicates() entfernen.

Fehlende Werte behandeln:

Fehlende Werte sind in HTML-Tabellen üblich. Du kannst sie mit df.dropna() entfernen oder durch einen anderen Wert ersetzen, z. B. mit df.fillna(0).

Spalten umbenennen:

Spaltennamen können aussagekräftiger sein. Verwende df.rename(columns={'alten_name': 'neuer_name'}), um sie umzubenennen.

Datentypen konvertieren:

Überprüfe die Datentypen der Spalten und konvertiere sie gegebenenfalls in den gewünschten Typ. Dies kann mit df['spaltenname'].astype(dtype) geschehen.

Formatierung entfernen:

HTML-Tabellen enthalten oft Formatierungen wie HTML-Tags. Entferne diese mit df['spaltenname'].str.replace('<br>', '').

Zusammenführen mehrerer Tabellen:

Wenn du mehrere Tabellen extrahiert hast, kannst du sie horizontal oder vertikal zusammenführen. Verwende dazu pd.concat() oder pd.merge().

Fortgeschrittene Verwendung: Bearbeitung komplexer HTML-Strukturen

Bei komplexeren HTML-Strukturen musst du möglicherweise zusätzliche Techniken anwenden, um die Tabellen erfolgreich zu extrahieren.

Verschachtelte Tabellen

Verschachtelte Tabellen, bei denen sich Tabellen innerhalb anderer Tabellen befinden, können eine Herausforderung darstellen. Pandas bietet die Option match an, um anzugeben, welche verschachtelte Tabelle extrahiert werden soll.

html = """
<table>
  <tr>
    <td>
      <table>
        ...
      </table>
    </td>
  </tr>
</table>
"""
tabellen = pd.read_html(html, match="table")

Tabelleneigenschaften extrahieren

Neben den Tabellendaten kannst du auch zusätzliche Informationen wie Kopf- und Fußzeileninformationen extrahieren. Verwende hierfür die Argumente header, footer und index_col.

html = """
<table>
  <thead>
    <tr>
      <th>Name</th>
      <th>Alter</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>John</td>
      <td>30</td>
    </tr>
  </tbody>
</table>
"""
tabellen = pd.read_html(html, header=0, index_col=0)

Tabellen mit unregelmäßigen Strukturen

Für Tabellen mit unregelmäßigen Strukturen, die nicht in das Standardformat passen, kannst du die Bibliothek Beautiful Soup verwenden, die erweiterte Steuermöglichkeiten für die HTML-Analyse bietet.

Tipps für die Handhabung komplexer HTML-Strukturen

• Verwende den Entwickler-Modus deines Browsers, um die HTML-Struktur zu inspizieren.
• Nutze reguläre Ausdrücke, um bestimmte Tabellen oder Daten zu extrahieren.
• Zerlege komplexe HTML-Strukturen in kleinere Teile auf, bevor du sie in Pandas lädst.
• Verwende benutzerdefinierte Funktionen, um bestimmte HTML-Elemente zu extrahieren und zu verarbeiten.

Tipps zur Optimierung der read_html()-Leistung

Durch die Befolgung einiger Best Practices kannst du die Leistung der read_html()-Funktion von Pandas optimieren:

Minimieren der HTML-Größe

Da read_html() den gesamten HTML-Code parsen muss, ist es wichtig, die Größe der zu parsenden HTML-Datei so gering wie möglich zu halten. Entferne überflüssige Tags, Kommentare und Leerzeichen aus dem HTML-Code.

Verwendung von benutzerdefinierten HTML-Parsern

Pandas verwendet standardmäßig den lxml-Parser zum Parsen von HTML. Wenn du jedoch mit der Leistung von lxml unzufrieden bist, kannst du stattdessen einen anderen HTML-Parser wie BeautifulSoup verwenden.

Angeben des flavor-Arguments

Das flavor-Argument teilt read_html() mit, welchen HTML-Parser es verwenden soll. Wenn du weißt, dass dein HTML einer bestimmten Spezifikation entspricht, kannst du den entsprechenden flavor angeben, z. B. html5lib oder bs4.

Paralleles Parsen

Wenn du mit sehr großen HTML-Dateien arbeitest, kannst du die parallele Verarbeitung aktivieren, indem du das multiprocessing-Argument auf True setzt. Dadurch werden die HTML-Dateien in kleinere Teile aufgeteilt und parallel geparst.

Beschränken der Anzahl der extrahierten Tabellen

Wenn dein HTML-Dokument mehrere Tabellen enthält, kannst du die Anzahl der extrahierten Tabellen durch Angabe des n-Arguments begrenzen. Dadurch wird die Extraktion beschleunigt, indem nur die angegebenen Tabellen verarbeitet werden.

Verwenden von keep_default_na

Wenn du leere Zellen in den extrahierten Tabellen mit NaN füllen möchtest, setze das keep_default_na-Argument auf True. Dies kann die Leistung verbessern, da ansonsten der Standardwert None verwendet wird, was zusätzliche Verarbeitung erfordert.

Caching von HTML-Dateien

Wenn du dieselbe HTML-Datei mehrmals parsen musst, solltest du den gelesenen HTML-Code zwischenspeichern. Dies kann die Leistung erheblich verbessern, indem das wiederholte Parsen des gleichen HTML-Codes vermieden wird.

Fehlerbehebung bei read_html()

Fehlende oder leere DataFrames

Wenn du einen leeren DataFrame erhältst, könnte es sein, dass:

• Die HTML-Tabelle nicht existiert oder nicht gültig ist.
• Die index- oder header-Argumente falsch gesetzt sind.
• Eine Spalte in der HTML-Tabelle den Namen index hat.

Fehlerhafte Daten

Falls die extrahierten Daten ungenau oder falsch sind, überprüfe Folgendes:

• Zeichensatz: Stelle sicher, dass der Zeichensatz der HTML-Seite mit dem Zeichensatz deines Codes übereinstimmt.
• Leerzeichen: Entferne übermäßige Leerzeichen oder Tabulatoren aus der HTML-Tabelle, da sie die Datenerkennung stören können.
• Fehlende Werte: Überprüfe, ob die HTML-Tabelle fehlende Werte enthält, die zu ungültigen Daten führen können.

Leistungsprobleme

Um die Leistung von read_html() zu verbessern:

• Verwende lxml statt html5lib: lxml ist ein schnellerer HTML-Parser als html5lib.
• Begrenze die Anzahl der extrahierten Tabellen: Lade nur die Tabellen, die du benötigst.
• Paralleisiere den Extraktionsprozess: Nutze die nthreads-Option, um die Extraktion auf mehrere Prozessoren zu verteilen.

Parse-Ausnahmen

Falls read_html() eine Parse-Ausnahme auslöst, könnte es sein, dass:

• Die HTML-Struktur ist ungültig oder beschädigt.
• Es handelt sich um eine komplexe oder verschachtelte HTML-Tabelle.
• Es gibt eine JavaScript-Abhängigkeit, die die Tabelle rendert.

Alternativen zu read_html()

Wenn read_html() deine Anforderungen nicht erfüllt, stehen dir alternative Bibliotheken zur Verfügung:

• lxml.html: Bietet eine umfassende HTML-Parsing-API für die Extraktion komplexer Tabellen.
• BeautifulSoup: Eine beliebte Bibliothek für HTML-Parsing, die ebenfalls zur Tabellenextraktion verwendet werden kann.
• html2text: Konvertiert HTML in Text, was eine einfachere Tabellenextraktion ermöglichen kann.

Alternativen zu read_html() für die HTML-Tabellenextraktion

Während Pandas read_html() eine leistungsstarke Option zum Extrahieren von HTML-Tabellen ist, gibt es auch eine Reihe von Alternativen, die du je nach deinen spezifischen Anforderungen in Betracht ziehen kannst.

Beautiful Soup

Beautiful Soup ist eine umfangreiche HTML-Parsing-Bibliothek, die dir detailliertere Kontrolle über die Extraktion von HTML-Elementen gibt. Es ermöglicht dir, selektive Abfragen für HTML-Tags anhand von Attributen, Klassen oder IDs durchzuführen.

from bs4 import BeautifulSoup

soup = BeautifulSoup(html_string, 'html.parser')
table = soup.find('table', {'id': 'example_table'})

Lxml

Lxml ist eine weitere leistungsstarke XML- und HTML-Parsing-Bibliothek, die XPath-Abfragen unterstützt. XPath ist eine Abfragesprache, mit der du komplexe HTML-Strukturen präzise durchsuchen kannst.

from lxml import html

tree = html.fromstring(html_string)
table = tree.xpath('//table[@id="example_table"]')[0]

Scrapy

Scrapy ist ein Web-Crawling-Framework, das speziell zum Extrahieren strukturierter Daten aus Websites entwickelt wurde. Es bietet eine Reihe von Werkzeugen zum Verwalten von Webanforderungen, Webseitenanalysen und Datenextraktion.

import scrapy

class TableExtractorSpider(scrapy.Spider):
    def parse(self, response):
        table = response.xpath('//table[@id="example_table"]')
        return table

Vor- und Nachteile

Jede dieser Alternativen hat ihre eigenen Stärken und Schwächen:

• Beautiful Soup: Bietet flexible Abfragefunktionen, kann aber langsamer sein als andere Bibliotheken.
• Lxml: Leistungsstark und XPath-fähig, erfordert jedoch eine steilere Lernkurve.
• Scrapy: Umfangreich und für das Web-Crawling konzipiert, kann jedoch für einfache Extraktionsaufgaben überdimensioniert sein.

Auswahl der richtigen Alternative

Die Wahl der richtigen Alternative zu read_html() hängt von deinen spezifischen Anforderungen ab. Wenn du nach einer flexiblen und detaillierten Extraktionslösung suchst, sind Beautiful Soup oder Lxml gute Optionen. Wenn du eine dedizierte Web-Crawling-Lösung benötigst, ist Scrapy eine gute Wahl.