HTML-Selektoren sind der Schlüssel zum Web-Scraping, denn sie ermöglichen es Entwicklern, bestimmte Elemente auf einer Webseite anzusteuern. Durch die Verwendung dieser Selektoren können Entwickler Daten präzise extrahieren.
Beim Web Scraping geht es darum, Daten von Websites durch Navigation in ihrer HTML-Struktur zu erhalten. HTML-Selektoren sind von entscheidender Bedeutung, denn sie ermöglichen es Ihnen, bestimmte Tags, Attribute oder Inhalte zu lokalisieren. Ob Sie nun Produktpreise oder Schlagzeilen extrahieren, Selektoren sind Ihr Leitfaden.
Die Verwendung von HTML-Selektoren rationalisiert die Datenextraktion und reduziert Fehler. Sie helfen Ihnen, sich auf wichtige Elemente zu konzentrieren, und sparen Zeit und Mühe beim Sammeln von Erkenntnissen aus Online-Quellen.
In diesem Blog werden wir untersuchen, wie man die unten aufgeführten Selektoren mit Python und der Bibliothek"Beautifulsoup" verwendet:
- Id Selektoren
- Klasse Selektoren
- Attribut-Selektoren
- Hierarchische Selektoren
- Kombination dieser Selektoren zusammen
ID-Selektoren
In HTML sind IDs eindeutige Bezeichner, die bestimmten Elementen zugewiesen werden und sicherstellen, dass keine zwei Elemente die gleiche ID haben. Diese Einzigartigkeit macht ID-Selektoren ideal für die Suche nach einzelnen Elementen auf einer Webseite. Wenn Sie z. B. eine Webseite mit mehreren Abschnitten scannen, kann jeder Abschnitt seine eigene ID haben, so dass Sie Daten aus einem bestimmten Abschnitt ohne Störungen extrahieren können.
Nehmen wir zum Beispiel diese Websiteinsbesondere das folgende Element <div id="pages"> ...</div>
Dieses Element enthält andere verschachtelte HTML-Elemente, aber das Wichtigste ist, dass dieses Element auf dieser Website einzigartig ist und wir dieses Szenario nutzen können, wenn wir zum Beispiel bestimmte Abschnitte der Website scrapen wollen. In diesem Fall enthält dieses Element einige andere Artikel, die wir weiter unten mit den anderen Selektoren erklären werden. Hier sehen Sie, wie dieser Abschnitt auf der Seite aussieht:
Lassen Sie uns ein einfaches Beispiel mit den Python-Bibliotheken "requests" und "bs4" untersuchen:
import requests
from bs4 import BeautifulSoup
# Step 1: Send a GET request to the website
url = "https://www.scrapethissite.com/pages/"
response = requests.get(url)
if response.status_code == 200:
# Step 2: Parse the HTML content with BeautifulSoup
soup = BeautifulSoup(response.text, 'html.parser')
# Step 3: Find the div with id="pages"
pages_div = soup.find("div", id="pages")
# Step 4: Display the content or handle it as needed
if pages_div:
print("Content of the div with id='pages':")
print(pages_div.text.strip())
else:
print("No div with id='pages' found.")
else:
print(f"Failed to retrieve the webpage. Status code: {response.status_code}")
Erläuterung:
- Eine Anfrage senden: Die Anforderungsbibliothek sendet eine GET-Anforderung, um den HTML-Inhalt von der Ziel-URL zu holen.
- HTML parsen: BeautifulSoup analysiert den HTML-Code, so dass wir die Dokumentstruktur durchsuchen können.
- Find Specific <div>: Wir verwenden
soup.find("div", id="pages")zum Auffinden der<div>Element mitid="Seiten". - Inhalt anzeigen: Wenn die
<div>gefunden wird, wird sein Inhalt gedruckt. Wenn nicht, erscheint eine Meldung, dass er fehlt.
Beschränkungen von ID-Selektoren:
ID-Selektoren sind leistungsstark, haben aber ihre Grenzen. Dynamische IDs, die sich bei jedem Laden der Seite ändern, können eine konsistente Datenextraktion erschweren. In solchen Situationen kann die Verwendung alternativer Selektoren für zuverlässige Ergebnisse erforderlich sein.
Klasse Selektoren
Klassenselektoren sind flexibel, denn sie ermöglichen es Ihnen, Gruppen von Elementen mit der gleichen Klasse zu markieren. Das macht sie für Webseiten mit wiederkehrenden Elementen unverzichtbar. Beispielsweise kann eine Website, die eine Liste von Produkten anzeigt, jedem Produktelement die gleiche Klasse zuweisen.
Nehmen wir wieder ein Beispiel mit diese Website. Oben haben wir eine <div id="pages"> Element mit ID Selector und in diesem div-Element gibt es einige Artikel, die die gleiche Klasse haben.
Wie Sie sehen können, haben wir vier Elemente mit der gleichen Klasse <div class="page">
So sehen sie auf der Website aus:
Im nachstehenden Code werden alle Elemente mit der Klasse "page" ausgewählt, wodurch eine Liste zurückgegeben wird, die für das weitere Parsing verwendet werden kann.
import requests
from bs4 import BeautifulSoup
# Step 1: Send a GET request to the website
url = "https://www.scrapethissite.com/pages/"
response = requests.get(url)
if response.status_code == 200:
# Step 2: Parse the HTML content with BeautifulSoup
soup = BeautifulSoup(response.text, 'html.parser')
# Step 3: Find all elements with class="page"
page_elements = soup.find_all("div", class_="page")
# Step 4: Save each element's text content in a list
pages_list = [page.text.strip() for page in page_elements]
print("Content of elements with class 'page':")
for i, page in enumerate(pages_list, start=1):
print(f"Page {i}:")
print(page)
print("-" * 20)
else:
print(f"Failed to retrieve the webpage. Status code: {response.status_code}")
Erläuterung:
- Eine Anfrage senden: Wir verwenden Anfragen, um eine GET-Anfrage an die URL zu senden und den HTML-Inhalt der Webseite abzurufen.
- Parsen Sie HTML mit BeautifulSoup: Wenn die Anfrage erfolgreich ist, analysiert BeautifulSoup das HTML und ermöglicht uns die Suche und Interaktion mit Elementen.
- Elemente nach Klasse suchen: Wir verwenden
soup.find_all("div", class_="page")zum Auffinden aller<div>Elemente mit der Klasse "page" und gibt sie als Liste zurück. - In Liste speichern: Wir extrahieren und bereinigen den Textinhalt der einzelnen Elemente und speichern ihn in einer Liste namens pages_list.
Beschränkungen von Klassen-Selektoren
Achten Sie bei der Verwendung von Klassenselektoren auf mögliche Probleme wie die Auswahl unbeabsichtigter Elemente. Mehrere Klassen auf einem einzigen Element können zusätzliche Filterung erfordern, um eine genaue Zielsetzung zu erreichen.
Attribut-Selektoren
Mit Attributselektoren können Sie Elemente auf der Grundlage des Vorhandenseins, des Wertes oder eines Teilwertes bestimmter Attribute innerhalb von HTML-Tags auswählen. Dies ist besonders hilfreich, wenn Klassen oder IDs nicht eindeutig sind oder wenn Sie Elemente mit dynamischen Attributen filtern müssen, wie z. B. Daten-* oder href Werte in Links.
Im folgenden Beispiel wählen wir alle Bilder auf dieser Seite aus Webseite und extrahieren ihre Quell-URLs oder src Attribute. So sieht das Element in der HTML-Struktur und der Webseitenansicht aus:
Im folgenden Code verwenden wir BeautifulSoup zum Parsen aller <img> Elemente und extrahiert deren src Attribute und speichert sie in einer Liste.
import requests
from bs4 import BeautifulSoup
# Step 1: Send a GET request to the website
url = "https://www.scrapethissite.com/pages/frames/"
response = requests.get(url)
if response.status_code == 200:
# Step 2: Parse the HTML content with BeautifulSoup
soup = BeautifulSoup(response.text, 'html.parser')
# Step 3: Find all <img> elements with a 'src' attribute
image_elements = soup.find_all("img", src=True)
# Step 4: Save the 'src' attributes in a list
images_list = [img['src'] for img in image_elements]
print("Image sources found on the page:")
for i, src in enumerate(images_list, start=1):
print(f"Image {i}: {src}")
else:
print(f"Failed to retrieve the webpage. Status code: {response.status_code}")
Beschränkungen von Klassen-Selektoren
Attributselektoren können nur Elemente mit statischen Attributen auswählen, was sie für dynamische Inhalte, wie z. B. Elemente, die über JavaScript geladen werden, weniger effektiv macht. Sie sind von stabilen HTML-Strukturen abhängig, so dass häufige Änderungen des Website-Layouts sie stören können. Außerdem können sie keine komplexe Filterung oder mehrere Bedingungen verwalten, was ihre Präzision einschränkt. Sie können auch unbeabsichtigte Elemente erfassen, wenn Attribute wie Klasse oder Name von mehreren Elementen gemeinsam genutzt werden.
Hierarchische Selektoren
Mit hierarchischen Selektoren können Sie HTML-Elemente auf der Grundlage ihrer Position und Beziehung zu anderen Elementen in der HTML-Struktur auswählen. Dieser Ansatz ist besonders nützlich bei der Arbeit mit Tabellen oder verschachtelten Listen, bei denen die Daten in einem Eltern-Kind-Format organisiert sind.
In diesem Beispiel verwenden wir hierarchische Selektoren, um Daten aus einer Tabelle mit Eishockeystatistiken zu holen, die auf diese Webseite.
Die Tabelle enthält Zeilen <tr> die jedes Team repräsentieren, und jede Zeile enthält Zellen <td> mit Informationen wie Mannschaftsname, Jahr, Siege und Niederlagen. Jede Zeile enthält die class="team"und identifiziert ihn als relevanten Eintrag in unseren Daten. Durch Navigieren von der <table> to each <tr> and then to each <td>können wir die Daten effizient und strukturiert erfassen.
Nachfolgend finden Sie zwei Bilder, die Ihnen verdeutlichen sollen, wo sich diese Tabelle in der HTML-Struktur befindet und wie sie auf der eigentlichen Webseite erscheint.
Schauen wir uns nun den folgenden Code an, um zu sehen, wie hierarchische Selektoren verwendet werden können, um diese Daten zu extrahieren:
import requests
from bs4 import BeautifulSoup
url = "https://www.scrapethissite.com/pages/forms/"
# Step 1: Send a GET request to the website
response = requests.get(url)
if response.status_code == 200:
# Step 2: Parse the HTML content with BeautifulSoup
soup = BeautifulSoup(response.text, 'html.parser')
# Step 3: Find all rows in the table with class="team"
teams_data = []
team_rows = soup.find_all("tr", class_="team")
# Step 4: Extract and store each team's data
for row in team_rows:
team = {
"name": row.find("td", class_="name").text.strip(),
"year": row.find("td", class_="year").text.strip(),
"wins": row.find("td", class_="wins").text.strip(),
"losses": row.find("td", class_="losses").text.strip(),
"ot_losses": row.find("td", class_="ot-losses").text.strip(),
"win_pct": row.find("td", class_="pct").text.strip(),
"goals_for": row.find("td", class_="gf").text.strip(),
"goals_against": row.find("td", class_="ga").text.strip(),
"goal_diff": row.find("td", class_="diff").text.strip(),
}
teams_data.append(team)
# Step 5: Display the extracted data
for team in teams_data:
print(team)
else:
print(f"Failed to retrieve the webpage. Status code: {response.status_code}")
Einschränkungen von hierarchischen Selektoren
Hierarchische Selektoren sind von der HTML-Struktur abhängig, so dass Änderungen im Layout das Scraping-Skript leicht zerstören können. Außerdem sind sie auf statische Inhalte beschränkt und können nicht auf Elemente zugreifen, die von JavaScript dynamisch geladen werden. Diese Selektoren erfordern oft eine präzise Navigation durch Eltern-Kind-Beziehungen, was bei tief verschachtelten Strukturen schwierig sein kann. Außerdem können sie beim Extrahieren verstreuter Daten ineffizient sein, da sie mehrere Ebenen durchlaufen müssen, um bestimmte Elemente zu erreichen.
Kombinierte Selektoren für besseres Targeting verwenden
Jeder Selektortyp dient einem bestimmten Zweck, und die Kombination dieser Selektoren ermöglicht es uns, in verschachtelten oder strukturierten Inhalten zu navigieren und Daten genau zu erfassen. Beispielsweise kann ein ID-Selektor helfen, den Hauptinhaltsbereich zu lokalisieren, Klassenselektoren können wiederholte Elemente isolieren, Attributselektoren können bestimmte Links oder Bilder extrahieren, und hierarchische Selektoren können Elemente erreichen, die in bestimmten Abschnitten verschachtelt sind. Zusammen bieten diese Techniken einen leistungsstarken Ansatz für das Scraping strukturierter Daten.
import requests
from bs4 import BeautifulSoup
# Target URL
url = "https://www.scrapethissite.com/pages/"
response = requests.get(url)
if response.status_code == 200:
# Step 2: Parse the HTML content with BeautifulSoup
soup = BeautifulSoup(response.text, 'html.parser')
# Use ID selector to find the main content
main_content = soup.find(id="pages")
# Use class selector to find each "page" section
pages = main_content.find_all("div", class_="page") if main_content else []
# Extract details from each "page" section using hierarchical selectors
for page in pages:
# Use hierarchical selector to find title link and URL within each "page"
title_tag = page.find("h3", class_="page-title")
title = title_tag.text.strip() if title_tag else "No Title"
link = title_tag.find("a")["href"] if title_tag and title_tag.find("a") else "No Link"
# Use class selector to find the description
description = page.find("p", class_="lead session-desc").text.strip() if page.find("p", class_="lead session-desc") else "No Description"
print(f"Title: {title}")
print(f"Link: {link}")
print(f"Description: {description}")
print("-" * 40)
else:
print(f"Failed to retrieve the webpage. Status code: {response.status_code}")
Erläuterung des Kodex
- ID-Selektor: Wir beginnen damit, den Hauptinhaltsbereich mit id="pages" zu finden, der die benötigten Abschnitte enthält.
- Klassenwähler: Innerhalb dieses Hauptbereichs verwenden wir
class="page"um jeden einzelnen Inhaltsblock zu finden, der einen Abschnitt von Interesse darstellt. - Hierarchische Selektoren: Innerhalb jedes "Seiten"-Blocks verwenden wir:
page.find("h3", class_="page-title")um den Titel zu finden.title_tag.find("a")["href"]um die Link-URL aus dem Anker-Tag im Titel abzurufen.
- Attribut-Selektor: Wir greifen auf das href-Attribut jedes Links zu, um die genauen URLs zu erfassen, die mit jedem Abschnitt verbunden sind.
- Ausgabe: Das Skript gibt den Titel, den Link und die Beschreibung jedes Abschnitts aus und bietet so einen strukturierten Überblick über die von der Seite ausgelesenen Daten.
Schlussfolgerung
Beim Web Scraping kann das Wissen um die Verwendung von HTML-Selektoren Ihre Fähigkeiten bei der Datenextraktion erheblich verbessern, so dass Sie wichtige Informationen genau erfassen können. Selektoren wie ID-, Klassen-, Attribut- und hierarchische Selektoren haben jeweils spezifische Verwendungszwecke für verschiedene Scraping-Aufgaben. Wenn Sie diese Tools zusammen verwenden, können Sie eine Vielzahl von Web-Scraping-Aufgaben sicher bewältigen.
Zum Üben bieten Websites wie Scrape This Site und Books to Scrape tolle Beispiele, mit denen Sie Ihre Fähigkeiten verfeinern können. Und wenn Sie Hilfe benötigen oder sich mit anderen Interessierten austauschen möchten, können Sie unserem Discord-Kanal unter https://discord.com/invite/scrape beitreten.
Viel Spaß beim Schaben!