Heim BlogWeb-Scraping So durchsuchen Sie HTML-Tabellen mit Python
Web-Scraping

So durchsuchen Sie HTML-Tabellen mit Python

von Kadek
geschrieben von Kadek
Elemente, die im Hauptteil der Tabelle gefunden werden. Wenn Sie unserer Logik folgen, besteht der nächste Schritt darin, jede einzelne Zeile in einem einzelnen Objekt zu speichern und diese zu durchlaufen, um die gewünschten Daten zu finden.

Versuchen wir zunächst, den Namen des ersten Mitarbeiters in der Konsole unseres Browsers mithilfe der Methode .querySelectorAll() auszuwählen. Ein wirklich nützliches Merkmal dieser Methode besteht darin, dass wir immer tiefer in die Hierarchie vordringen können, indem wir das Größer-als-Symbol (>) implementieren, um das übergeordnete Element (links) und das untergeordnete Element, das wir greifen möchten (rechts), zu definieren.

document.querySelectorAll('table.stripe > tbody > tr > td')(0)

PhytonPhyton

Das könnte nicht besser funktionieren. Wie Sie sehen, schnappen wir uns erst einmal alle

Elemente, diese werden zu einer Knotenliste. Da wir uns nicht darauf verlassen können, dass eine Klasse jede Zelle erfasst, müssen wir nur ihre Position im Index kennen und die erste, Name, ist 0.

Von dort aus können wir unseren Code wie folgt schreiben:

for row in rows:
name = row.find_all('td')(0).text
print(name)

Vereinfacht ausgedrückt nehmen wir jede Zeile einzeln und suchen alle darin enthaltenen Zellen. Sobald wir die Liste haben, greifen wir nur auf die erste im Index (Position 0) und schließen mit der .text-Methode ab Greifen Sie auf den Text des Elements zu und ignorieren Sie die HTML-Daten, die wir nicht benötigen.

TischschaberTischschaber

Da ist sie, eine Liste mit allen Namen der Mitarbeiter! Im Übrigen folgen wir einfach der gleichen Logik:

position = row.find_all('td')(1).text
office = row.find_all('td')(2).text
age = row.find_all('td')(3).text
start_date = row.find_all('td')(4).text
salary = row.find_all('td')(5).text

Allerdings ist es nicht besonders hilfreich, all diese Daten auf unserer Konsole ausgedruckt zu haben. Speichern wir diese Daten stattdessen in einem neuen, nützlicheren Format.

5. Speichern tabellarischer Daten in einer JSON-Datei

Obwohl wir problemlos eine CSV-Datei erstellen und unsere Daten dorthin senden könnten, wäre das nicht das am besten zu handhabende Format, wenn wir mit den gescrapten Daten etwas Neues erstellen könnten.

Dennoch ist hier ein Projekt, das wir vor ein paar Monaten durchgeführt haben und das erklärt, wie man eine CSV-Datei zum Speichern von Scraped-Daten erstellt.

Die gute Nachricht ist, dass Python über ein eigenes JSON-Modul für die Arbeit mit JSON-Objekten verfügt, sodass wir nichts installieren müssen, sondern es einfach importieren müssen.

Aber bevor wir mit der Erstellung unserer JSON-Datei fortfahren können, müssen wir all diese gescrapten Daten in eine Liste umwandeln. Dazu erstellen wir ein leeres Array außerhalb unserer Schleife.

Und dann hängen Sie die Daten daran an, wobei jede Schleife ein neues Objekt an das Array anhängt.

employee_list.append({
	'Name': name,
	'Position': position,
	'Office': office,
	'Age': age,
	'Start date': start_date,
	'salary': salary
})

Wenn wir print(employee_list)hier ist das Ergebnis:

Drucken Sie PhytonDrucken Sie Phyton

Immer noch etwas chaotisch, aber wir haben eine Reihe von Objekten, die bereit sind, in JSON umgewandelt zu werden.

Notiz: Als Test haben wir die Länge ausgedruckt employee_list und es wurde 57 zurückgegeben, was der korrekten Anzahl von Zeilen entspricht, die wir gescrapt haben (Zeilen sind jetzt Objekte innerhalb des Arrays).

Für den Import einer Liste in JSON sind lediglich zwei Codezeilen erforderlich:

with open('json_data', 'w') as json_file:
json.dump(employee_list, json_file, indent=2)
  • Zuerst öffnen wir eine neue Datei und geben den gewünschten Namen für die Datei ein (json_data) und 'w', da wir Daten darauf schreiben möchten.
  • Als nächstes verwenden wir die .dump() Funktion, um die Daten aus dem Array zu sichern (employee_list) Und indent=2 Jedes Objekt hat also seine eigene Zeile, anstatt dass sich alles in einer unlesbaren Zeile befindet.

6. Ausführen des Skripts und des vollständigen Codes

Wenn Sie mitverfolgt haben, Ihre Codebasis sollte so aussehen:

#dependencies
import requests
from bs4 import BeautifulSoup
import json

url = 'http://api.scraperapi.com?api_key=51e43be283e4db2a5afbxxxxxxxxxxx&url=https://datatables.net/examples/styling/stripe.html'

#empty array
employee_list = ()

#requesting and parsing the HTML file
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

#selecting the table
table = soup.find('table', class_ = 'stripe')

#storing all rows into one variable
for employee_data in table.find_all('tbody'):
rows = employee_data.find_all('tr')

#looping through the HTML table to scrape the data
for row in rows:
name = row.find_all('td')(0).text
position = row.find_all('td')(1).text
office = row.find_all('td')(2).text
age = row.find_all('td')(3).text
start_date = row.find_all('td')(4).text
salary = row.find_all('td')(5).text

#sending scraped data to the empty array
employee_list.append({
	'Name': name,
	'Position': position,
	'Office': office,
	'Age': age,
	'Start date': start_date,
	'salary': salary
})

#importing the array to a JSON file
with open('employee_data', 'w') as json_file:
json.dump(employee_list, json_file, indent=2)

Notiz: Wir haben einige Kommentare für den Kontext hinzugefügt.

Und hier ist ein Blick auf die ersten drei Objekte aus der JSON-Datei:

Json-DateiJson-Datei

Durch das Speichern der Scraped-Daten im JSON-Format können wir die Informationen für neue Anwendungen oder wiederverwenden

Scrapen Sie HTML-Tabellen mit komplexen Headern.

Das Scrapen von Daten aus HTML-Tabellen ist ziemlich einfach, aber was passiert, wenn Sie auf eine Tabelle mit komplexeren Strukturen, wie z. B. verschachtelten Tabellen, stoßen? rowspansoder colspans? In diesen Fällen müssen Sie möglicherweise eine ausgefeiltere Parsing-Logik implementieren.

Bevor wir beginnen, sehen Sie sich unten an, wie die Zieltabelle aussieht:

Scraping von HTML-Tabellen mit komplexen HeadernScraping von HTML-Tabellen mit komplexen Headern

Wie Sie sehen, hat diese Tabelle eine zweistufige Kopfstruktur:

  • Die erste Zeile enthält umfassendere Kategorien: „Name„, „Position„, Und „Kontakt„.

  • In der zweiten Zeile werden diese Kategorien weiter aufgeschlüsselt.

Lasst uns den Tisch abkratzen!

Einrichten der Scraping-Umgebung

Zuerst müssen wir die benötigten Bibliotheken importieren. ScraperAPI hilft uns bei der Handhabung aller Anti-Scraping-Maßnahmen, die auf der Website möglicherweise vorhanden sind, einschließlich der Verwaltung von Headern und rotierenden IPs, falls erforderlich: 

import requests
from bs4 import BeautifulSoup
import pandas as pd

api_key = 'YOUR_API_KEY'
url = 'https://datatables.net/examples/basic_init/complex_header.html'

Erstellen der Scraping-Funktion

Fahren wir mit der Erstellung einer Funktion fort scrape_complex_table Das übernimmt den gesamten Schabevorgang. Diese Funktion verwendet unsere URL als Eingabe und gibt einen Pandas-DataFrame zurück, der die strukturierten Tabellendaten enthält: 

def scrape_complex_table(url):
    # Send a request to the webpage
    payload = {'api_key': api_key, 'url': url}
    response = requests.get('https://api.scraperapi.com', params=payload)
    soup = BeautifulSoup(response.text, 'html.parser')

Diese Funktion verwendet requests.get um eine GET-Anfrage an ScraperAPI zu senden, die wiederum die Zielwebseite abruft. Anschließend analysieren wir den HTML-Inhalt mit BeautifulSoup.

Auffinden der Zieltabelle

Wir lokalisieren die Tabelle im analysierten HTML mithilfe von it id Attribut. 

# Find the target table
    table = soup.find('table', id='example')

Diese Zeile findet den ersten

element with
id='example'.

Header extrahieren und kombinieren

Wir extrahieren die erste und zweite Ebene der Überschriften und kombinieren sie zu einer einzigen Liste mit Spaltennamen. 

# Extract and combine headers
    headers_level1 = (th.text.strip() for th in table.select('thead tr:nth-of-type(1) th'))
    headers_level2 = (th.text.strip() for th in table.select('thead tr:nth-of-type(2) th'))

    combined_headers = ()
    for i, header in enumerate(headers_level1):
        if header == 'Name':
            combined_headers.append(header)
        elif header == 'Position':
            combined_headers.extend((f"{header} - {col}" for col in ('Title', 'Salary')))
        elif header == 'Contact':
            combined_headers.extend((f"{header} - {col}" for col in ('Office', 'Extn.', 'Email')))

Hier verwenden wir CSS-Selektoren, um auf die Kopfzeilen abzuzielen. Anschließend durchlaufen wir die Header der ersten Ebene und hängen je nach Header entsprechende Header der zweiten Ebene an unsere an combined_headers Liste.

Extrahieren von Daten aus dem Tabellenkörper

Wir extrahieren die Daten aus jeder Zeile im Tabellenkörper.

# Extract data from table body
    rows = ()
    for row in table.select('tbody tr'):
        cells = (cell.text.strip() for cell in row.find_all('td'))
        rows.append(cells)

Dieser Code durchläuft jeden

in the

, extracts the text from each

, and
stores the data in the rows Liste.

Erstellen des DataFrame

Wir erstellen einen Pandas DataFrame unter Verwendung der kombinierten Header und extrahierten Daten. Dieser DataFrame organisiert unsere Daten in einem strukturierten Format mit entsprechenden Spaltennamen. 

# Create DataFrame
    df = pd.DataFrame(rows, columns=combined_headers)
    return df

Ausführen des Scrapers und Speichern von Daten

Wir nennen das scrape_complex_table Funktion, zeigen Sie die ersten paar Zeilen des DataFrame an und speichern Sie es in einer CSV-Datei. 

result_df = scrape_complex_table(url)

# Display the first few rows of the result
print(result_df.head())

result_df.to_csv('complex_table_data.csv', index=False)
print("Data has been saved to 'complex_table_data.csv'")

Dadurch werden die oberen Zeilen des DataFrame gedruckt und die gesamten Daten in einer Datei mit dem Namen gespeichert complex_table_data.csv.

Alles zusammenfügen

So sollte der vollständige Code nach der Kombination aller Schritte aussehen: 

import requests
from bs4 import BeautifulSoup
import pandas as pd

api_key = 'your_api_key_here'  # Replace with your actual ScraperAPI key

url = 'https://datatables.net/examples/basic_init/complex_header.html'

def scrape_complex_table(url):
   
    payload = {'api_key': api_key, 'url': url}
    response = requests.get('https://api.scraperapi.com', params=payload)
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # Find the target table
    table = soup.find('table', id='example')
    
    # Extract and combine headers
    headers_level1 = (th.text.strip() for th in table.select('thead tr:nth-of-type(1) th'))
    headers_level2 = (th.text.strip() for th in table.select('thead tr:nth-of-type(2) th'))
    
    combined_headers = ()
    for i, header in enumerate(headers_level1):
        if header == 'Name':
            combined_headers.append(header)
        elif header == 'Position':
            combined_headers.extend((f"{header} - {col}" for col in ('Title', 'Salary')))
        elif header == 'Contact':
            combined_headers.extend((f"{header} - {col}" for col in ('Office', 'Extn.', 'Email')))
    
    # Extract data from table body
    rows = ()
    for row in table.select('tbody tr'):
        cells = (cell.text.strip() for cell in row.find_all('td'))
        rows.append(cells)
    
    
    df = pd.DataFrame(rows, columns=combined_headers)
    return df

# Scrape the table
result_df = scrape_complex_table(url)

# Display the first few rows of the result
print(result_df.head())

result_df.to_csv('complex_table_data.csv', index=False)
print("Data has been saved to 'complex_table_data.csv'")

Notiz: Stellen Sie sicher, dass Sie ersetzt haben
'your_api_key_here' mit Ihrem tatsächlichen ScraperAPI-Schlüssel, bevor Sie das Skript ausführen.

Scraping von paginierten HTML-Tabellen mit Python

Beim Umgang mit großen Datensätzen werden Tabellen häufig auf mehrere Seiten aufgeteilt, um die Ladezeiten und das Benutzererlebnis zu verbessern. Traditionell würde dies die Einrichtung eines Headless-Browsers mit Tools wie Selenium erfordern. Mit dem Render-Befehlssatz von ScraperAPI können wir jedoch die gleichen Ergebnisse effizienter erzielen.

Notiz: Sehen Sie sich dieses ausführliche Tutorial zum Web Scraping mit Selenium an, um mehr zu erfahren.

Grundlegendes zum Umgang mit Paginierungen

In unserem etablierten Beispiel ist die Tabelle mit „>“ und „

Grundlegendes zum Umgang mit PaginierungenGrundlegendes zum Umgang mit Paginierungen

Um alle Daten zu extrahieren, müssen wir Folgendes tun:

  • Laden Sie die Startseite
  • Klicken Sie auf die Schaltfläche „>“.
  • Warten Sie, bis neue Daten geladen sind
  • Wiederholen Sie diesen Vorgang, bis alle Seiten verarbeitet sind

Verwendung des Render-Anweisungssatzes von ScraperAPI

Anstatt einen Browser manuell zu steuern, können wir über deren API Anweisungen an den Headless-Browser von ScraperAPI senden.

Mit dem Render-Anweisungssatz von ScraperAPI können Sie über einen API-Aufruf Anweisungen an einen Headless-Browser senden und ihn anleiten, welche Aktionen beim Rendern der Seite ausgeführt werden sollen. Diese Anweisungen werden als JSON-Objekt in den API-Anfrageheadern gesendet.

Lassen Sie uns kurz demonstrieren, wie Sie eine paginierte Tabelle mit dem Render-Befehlssatz von ScraperAPI scrapen:

Konfigurieren von ScraperAPI und Renderanweisungen

Zuerst richten wir unseren ScraperAPI-Schlüssel und die Ziel-URL ein, die wir scrapen möchten. Denken Sie daran, es auszutauschen 'your_api_key' mit Ihrem tatsächlichen ScraperAPI-Schlüssel. 

api_key = 'your_api_key'  # Replace with your actual ScraperAPI key

target_url = 'https://datatables.net/examples/styling/stripe.html'

Jetzt definieren wir den Satz von Renderanweisungen.

# Configuration for ScraperAPI's render instructions
config = ({
    "type": "loop",
    "for": 5,  # Number of times to execute the instructions
    "instructions": (
        {
            "type": "click",
            "selector": {
                "type": "css",
                "value": "button.dt-paging-button.next" 
            }
        },
        {
            "type": "wait",
            "value": 3  # Wait time in seconds after clicking
        }
    )
})

Der loop Die Anweisung wiederholt den Befehlssatz eine bestimmte Anzahl von Malen ("for": 5). Während die Klickanweisung a simuliert click Klicken Sie auf die Schaltfläche „>“, um zur nächsten Seite zu navigieren.

Stellen Sie die Anfrage an ScraperAPI

Nachdem wir die Renderanweisungen definiert haben, müssen wir sie konvertieren
config Wörterbuch in eine JSON-Zeichenfolge umwandeln, da ScraperAPI erfordert, dass die Anweisungen im JSON-Format vorliegen, wenn sie in den Anforderungsheadern enthalten sind. 

config_json = json.dumps(config)

Anschließend bereiten wir die Header und Nutzdaten für die GET-Anfrage an ScraperAPI vor: 

# Headers to include ScraperAPI instructions
headers = {
    'x-sapi-api_key': api_key,
    'x-sapi-render': 'true',
    'x-sapi-instruction_set': config_json
}

# Payload with the target URL
payload = {'url': target_url}

In den Überschriften:

  • 'x-sapi-api_key' Hier geben Sie Ihren ScraperAPI-Schlüssel zur Authentifizierung ein.
  • 'x-sapi-render' ist auf „true“ gesetzt, um das Rendern mit einem Headless-Browser zu ermöglichen und so die Ausführung von JavaScript und das dynamische Laden von Inhalten zu ermöglichen.

  • 'x-sapi-instruction_set' enthält die Renderanweisungen im JSON-Format, mit dem wir zuvor konvertiert haben
    json.dumps(config).

Die Nutzlast umfasst lediglich die 'url' Schlüssel mit dem
target_url Wert, der die Webseite angibt, die wir durchsuchen möchten.

Verarbeitung der Tabellendaten

Sobald wir die Antwort haben, können wir die Tabellendaten mit BeautifulSoup verarbeiten: 

# Parse the HTML content
soup = BeautifulSoup(response.text, 'html.parser')
employee_list = ()

# Find and process the table
table = soup.find('table', class_='stripe')

# Extract data from all rows
for employee_data in table.find_all('tbody'):
    rows = employee_data.find_all('tr')
    
    for row in rows:
        cells = row.find_all('td')
        employee_list.append({
            'Name': cells(0).text,
            'Position': cells(1).text,
            'Office': cells(2).text,
            'Age': cells(3).text,
            'Start date': cells(4).text,
            'salary': cells(5).text
        })

# Save the data to a JSON file
with open('employee_data.json', 'w') as json_file:
    json.dump(employee_list, json_file, indent=2)

Vorteile der Verwendung von Renderanweisungen

Die Verwendung der Render-Anweisungen von ScraperAPI bietet mehrere Vorteile gegenüber der herkömmlichen Browser-Automatisierung:

  • Es ist nicht erforderlich, Selenium oder einen WebDriver zu installieren und zu verwalten
  • Einfacherer Code mit weniger Abhängigkeiten
  • Bessere Handhabung von Anti-Bot-Maßnahmen durch ScraperAPI
  • Zuverlässigere Ausführung mit integrierten Wartezeiten und Wiederholungsversuchen
  • Es kann problemlos und ohne Browserabhängigkeiten auf Servern bereitgestellt werden

Umgang mit Fehlern beim Scraping von HTML-Tabellen

HTML-Tabellen auf echten Websites haben oft komplexe Layouts, was es für Anfänger schwierig macht, sie zu bewältigen. Diese Tabellen können gemischte Datentypen, verschachtelte Elemente, verbundene Zellen und andere komplizierte Strukturen enthalten, die das Parsen der Tabelle beim Scraping erschweren.

Lassen Sie uns einige häufig auftretende Probleme und ihre Lösungen untersuchen, um Ihr Table Scraping effizienter und zuverlässiger zu gestalten:

1. Umgang mit leeren Zellen und fehlenden Daten

Leere Zellen oder fehlende Daten können dazu führen, dass Ihr Scraping-Skript fehlschlägt oder unvollständige Ergebnisse liefert. So gehen Sie elegant damit um: 

def extract_cell_data(cell):
    # Handle empty cells
    if not cell:
        return "N/A"
    
    # Handle cells with only whitespace
    if cell.text.strip() == "":
        return "N/A"
        
    return cell.text.strip()

2. JavaScript-injizierte Tabellen

Einige Tabellen werden mithilfe von JavaScript dynamisch generiert. Das bedeutet, dass die Daten nicht in der ersten HTML-Antwort vorhanden sind, sondern nach der Darstellung durch einen Browser in die Seite eingefügt werden. Herkömmliche Scraping-Methoden können diesen Inhalt möglicherweise nicht abrufen, da sie kein JavaScript ausführen.

Mit dem Render-Befehlssatz von ScraperAPI können Sie Benutzerinteraktionen simulieren und JavaScript in einer Headless-Browserumgebung ausführen. Dadurch können Sie dynamisch geladene Tabellen durchsuchen, ohne auf komplexe Tools wie Selenium zurückgreifen zu müssen. 

(
  {
    "type": "input",
    "selector": { "type": "css", "value": "#searchInput" },
    "value": "cowboy boots"
  },
  {
    "type": "click",
    "selector": {
      "type": "css",
      "value": "#search-form button(type=\"submit\")"
    }
  },
  {
    "type": "wait_for_selector",
    "selector": { "type": "css", "value": "#content" }
  }
)

Notiz: Weitere Informationen zum Scraping von Javascript-Tabellen finden Sie in unserem ausführlichen Leitfaden.

3. Fehlerhafte HTML-Tabellen

Einige Tabellen haben möglicherweise eine ungültige HTML-Struktur oder fehlende schließende Tags. Ein besserer Parser für diesen Fall wäre html5lib. So gehen Sie damit um: 

def clean_table_html(html_content):
    # Use html5lib parser for better handling of malformed HTML
    soup = BeautifulSoup(html_content, 'html5lib')
    
    # Function to check if table is valid
    def is_valid_table(table):
        if not table.find('tr'):
            return False
        rows = table.find_all('tr')
        if not rows:
            return False
        return True
    
    # Find all tables and process only valid ones
    tables = ()
    for table in soup.find_all('table'):
        if is_valid_table(table):
            # Clean up any invalid nested tables
            for nested_table in table.find_all('table'):
                nested_table.decompose()
            tables.append(table)
    
    return tables

4. Verwendung von Pandas anstelle von MechanicalSoup oder BeautifulSoup

Die Verwendung von Pandas zum Scrapen von HTML-Tabellen spart viel Zeit und macht den Code zuverlässiger, da Sie die gesamte Tabelle auswählen und nicht einzelne Elemente, die sich im Laufe der Zeit ändern können.

Der read_html Mit der Methode können Sie Tabellen direkt abrufen, ohne das gesamte HTML-Dokument zu analysieren. Das Extrahieren von Tabellen ist viel schneller, da es für diese spezielle Aufgabe optimiert ist. Außerdem wird direkt ein DataFrame zurückgegeben, was die Bereinigung, Transformation und Analyse der Daten erleichtert.

Scraping von HTML-Tabellen mit Pandas

Bevor Sie die Seite verlassen, möchten wir einen zweiten Ansatz zum Scrapen von HTML-Tabellen untersuchen. In wenigen Codezeilen können wir alle Tabellendaten aus einem HTML-Dokument extrahieren und sie mithilfe von Pandas in einem Datenrahmen speichern.

Erstellen Sie einen neuen Ordner im Projektverzeichnis (wir haben ihn pandas-html-table-scraper genannt) und erstellen Sie einen neuen Dateinamen mit dem Namen pandas_table_scraper.py.

Öffnen wir ein neues Terminal und navigieren wir zu dem Ordner, den wir gerade erstellt haben (cd pandas-html-table-scraper) und installieren von dort aus pandas:

Und wir importieren es oben in die Datei.

Pandas verfügt über eine Funktion namens read_html(), die im Grunde die Ziel-URL für uns auswertet und alle HTML-Tabellen als Liste von DataFrame-Objekten zurückgibt.

Damit dies funktioniert, muss die HTML-Tabelle jedoch zumindest einigermaßen ordentlich strukturiert sein, da die Funktion nach Elementen wie sucht

um die Tabellen in der Datei zu identifizieren.

Um die Funktion zu verwenden, erstellen wir eine neue Variable und übergeben ihr die zuvor verwendete URL:

employee_data = pd.read_html('http://api.scraperapi.com?api_key=51e43be283e4db2a5afbxxxxxxxxxxxx&url=https://datatables.net/examples/styling/stripe.html')

Beim Drucken wird eine Liste der HTML-Tabellen auf der Seite zurückgegeben.

HTML-PhytonHTML-Phyton

Wenn wir die ersten drei Zeilen im DataFrame vergleichen, stimmen sie perfekt mit dem überein, was wir mit Beautiful Soup herausgesucht haben.

Um mit JSON zu arbeiten, verfügt Pandas über eine integrierte .to_json()-Funktion. Es konvertiert eine Liste von DataFrame-Objekten in einen JSON-String

Alles, was wir tun müssen, ist, die Methode in unserem DataFrame aufzurufen und den Pfad und das Format (Aufteilung, Daten, Datensätze, Index usw.) zu übergeben und den Einzug hinzuzufügen, um die Lesbarkeit zu verbessern:

employee_data(0).to_json('./employee_list.json', orient='index', indent=2)

Wenn wir jetzt unseren Code ausführen, ist hier die resultierende Datei:

TischschaberTischschaber

Beachten Sie, dass wir unsere Tabelle aus dem Index ((0)) auswählen mussten, da .read_html() eine Liste und kein einzelnes Objekt zurückgibt.

Hier ist der vollständige Code als Referenz:

import pandas as pd

employee_data = pd.read_html('http://api.scraperapi.com?api_key=51e43be283e4db2a5afbxxxxxxxxxxxx&url=https://datatables.net/examples/styling/stripe.html')

employee_data(0).to_json('./employee_list.json', orient='index', indent=2)

Ausgestattet mit diesem neuen Wissen sind Sie bereit, praktisch jede HTML-Tabelle im Web zu durchsuchen. Denken Sie daran: Wenn Sie verstehen, wie die Website aufgebaut ist und welche Logik dahinter steckt, gibt es nichts, was Sie nicht löschen können.

Allerdings funktionieren diese Methoden nur, solange sich die Daten in der HTML-Datei befinden. Wenn Sie auf eine dynamisch generierte Tabelle stoßen, müssen Sie einen neuen Ansatz finden. Für diese Art von Tabellen haben wir eine Schritt-für-Schritt-Anleitung zum Scrapen von JavaScript-Tabellen mit Python erstellt, ohne dass Headless-Browser erforderlich sind.

Bis zum nächsten Mal, viel Spaß beim Schaben!

Das könnte Sie interessieren

Mein Name ist Kadek und ich bin ein Student aus Indonesien und studiere derzeit Informatik in Deutschland. Dieser Blog dient als Plattform, auf der ich mein Wissen zu Themen wie Web Scraping, Screen Scraping, Web Data Mining, Web Harvesting, Web Data Extraction und Web Data Parsing teilen kann.

Related Posts

Sichere Proxys für die Aggregation von Finanzdaten

Beste Proxys zur Umgehung von YouTube-Bot-Blockern

Web Scraping in SEO: Die 7 häufigsten Anwendungsfälle

Die 7 besten Proxys für die KI-Datenerfassung

Die 15 häufigsten Web Scraping-Fehler und wie man...

Die 10 besten Ticket-Proxys zum Scrapen jeglicher Ticket-Webdaten

Hinterlasse einen Kommentar

Speichern Sie meinen Namen, meine E-Mail-Adresse und meine Website in diesem Browser für den nächsten Kommentar.

© 2023 WebDataExtraction
@2021 - All Right Reserved. Designed and Developed by PenciDesign