Vereinfachtes Web Scraping – Scraping von Mikroformaten
Einleitung
Unter Web Scraping versteht man das automatische Extrahieren von Daten von Websites. Dabei geht es darum, Programme zu schreiben, die Webseitenstrukturen verstehen und die relevanten Informationen extrahieren können. Während Web Scraping bei komplexen Websites eine Herausforderung darstellen kann, gibt es bestimmte Techniken, die die Arbeit erleichtern. Eine dieser Techniken ist das Scraping von Mikroformaten.
Mikroformate stellen semantische Metadaten bereit, die auf standardisierte Weise in den HTML-Code eingebettet sind. Sie erleichtern es Programmen, aussagekräftige Informationen aus Webseiten zu extrahieren. In diesem Leitfaden lernen wir die Grundlagen von Mikroformaten, die gängigen Typen und wie man sie für müheloses Web-Scraping mit Python nutzt.
Was sind Mikroformate?
Mikroformate wurden entwickelt, um die Darstellung wichtiger Webdatenobjekte zu standardisieren, damit sie maschinenlesbar sind. Am häufigsten werden Mikroformate zum Erstellen von Vorschaukarten für Webseiten verwendet. Sie werden am häufigsten verwendet, um Datenansichten für Suchmaschinen, soziale Netzwerke und andere Kommunikationskanäle bereitzustellen.
Wenn Sie beispielsweise einen Link in den sozialen Medien oder bei Slack veröffentlichen, wird eine Vorschaukarte mit Titel, Beschreibung und Miniaturansicht angezeigt. Dies wird durch das Scrapen von Mikroformaten von dieser Seite generiert.
Der einzige Nachteil besteht darin, dass Mikroformate nicht den gesamten Seitendatensatz enthalten. Möglicherweise müssen wir den Mikroformat-Parser um HTML-Parsing erweitern, indem wir Tools wie Beautiful Soup oder CSS Selector und XPath-Parser verwenden.
Beliebte Mikroformattypen
Im Internet werden mehrere Mikroformatstandards verwendet. Sehen wir uns einige beliebte Typen an und wie man sie mithilfe der Python-Extruct-Bibliothek extrahiert.
JSON-LD
JSON-LD ist das beliebteste moderne Mikroformat. Es verwendet eingebettete JSON-Dokumente, die schema.org-Objekte direkt darstellen.
Hier ist ein Beispiel für ein JSON-LD-Markup und wie man es mit extruct analysiert:
import extruct
html = """<script type="application/ld+json">
{
"@context": "http://schema.org",
"@type": "Person",
"name": "John Doe",
"image": "johndoe.jpg",
"jobTitle": "Software Engineer",
"telephone": "(555) 555-5555",
"email": "[email protected]",
"address": {
"@type": "PostalAddress",
"streetAddress": "123 Main St",
"addressLocality": "Anytown",
"addressRegion": "CA",
"postalCode": "12345"
}
}
</script>"""
data = extruct.JsonLdExtractor().extract(html)
print(data)Dadurch wird ein JSON-LD-Personenobjekt mit schema.org-Feldern wie Name, Bild, Jobtitel usw. ausgegeben.
JSON-LD ist einfach zu implementieren, kann jedoch zu Abweichungen bei den Seitendaten führen, da diese von den sichtbaren Daten getrennt sind.
Mikrodaten
Mikrodaten sind das zweitbeliebteste Format, das HTML-Attribute zum Markieren von Mikroformatfeldern verwendet. Dies eignet sich hervorragend für Web-Scraping, da es sichtbare Seitendaten abdeckt.
Hier ist ein Beispiel und wie man es analysiert:
html = """<div itemscope itemtype="http://schema.org/Person">
<h1 itemprop="name">John Doe</h1>
<img itemprop="image" src="johndoe.jpg" alt="John Doe">
<p itemprop="jobTitle">Software Engineer</p>
<p itemprop="telephone">(555) 555-5555</p>
<p itemprop="email"><a href="mailto:[email protected]">[email protected]</a></p>
<div itemprop="address" itemscope itemtype="http://schema.org/PostalAddress">
<p>
<span itemprop="streetAddress">123 Main St</span>,
<span itemprop="addressLocality">Anytown</span>,
<span itemprop="addressRegion">CA</span>
<span itemprop="postalCode">12345</span>
</p>
</div>
</div>"""
data = extruct.MicrodataExtractor().extract(html)
print(data)Mikrodaten stimmen besser mit den Quelldaten überein, da dieselben Daten verwendet werden, die auf der Seite angezeigt werden.
RDFa
RDFa ähnelt Microdata und verwendet HTML-Attribute für Mikroformate. Es bietet die gleichen Vorteile wie Microdata.
Hier ist ein Beispiel:
html = """<div vocab="http://schema.org/" typeof="Person">
<h1 property="name">John Doe</h1>
<img property="image" src="johndoe.jpg" alt="John Doe"/>
<p property="jobTitle">Software Engineer</p>
<p property="telephone">(555) 555-5555</p>
<p property="email"><a href="mailto:[email protected]">[email protected]</a></p>
<div property="address" typeof="PostalAddress">
<p>
<span property="streetAddress">123 Main St</span>,
<span property="addressLocality">Anytown</span>,
<span property="addressRegion">CA</span>
<span property="postalCode">12345</span>
</p>
</div>
</div>"""
data = extruct.RDFaExtractor().extract(html)
print(data)RDFa-Daten stimmen mit der tatsächlichen Quelle überein, die Ausgabe ist jedoch etwas verworren.
OpenGraph
OpenGraph von Facebook wird zum Generieren von Vorschaukarten in sozialen Beiträgen verwendet. Es unterstützt schema.org-Objekte, wird jedoch selten über die Website-Vorschau hinaus verwendet.
Hier ist ein Beispiel:
html = """<head>
<meta property="og:type" content="profile"/>
<meta property="og:title" content="John Doe"/>
<meta property="og:image" content="johndoe.jpg"/>
<meta property="og:description" content="Software Engineer"/>
<meta property="og:phone_number" content="(555) 555-5555"/>
<meta property="og:email" content="[email protected]"/>
<meta property="og:street-address" content="123 Main St"/>
<meta property="og:locality" content="Anytown"/>
<meta property="og:region" content="CA"/>
<meta property="og:postal-code" content="12345"/>
</head>"""
data = extruct.OpenGraphExtractor().extract(html)
print(data) Opengraph kann von Seitendaten abweichen, da es nicht Teil der natürlichen Seite ist.
Mikroformat
Mikroformat ist eines der ältesten Formate vor schema.org mit eigenen Schemata für Personen, Organisationen, Ereignisse, Produkte usw.
Hier ist ein Beispiel:
html = """<div class="h-card">
<h1 class="fn">John Doe</h1>
<img class="photo" src="johndoe.jpg" alt="John Doe">
<p class="title">Software Engineer</p>
<p class="tel">(555) 555-5555</p>
<a class="email" href="mailto:[email protected]">[email protected]</a>
<div class="adr">
<span class="street-address">123 Main St</span>,
<span class="locality">Anytown</span>,
<span class="region">CA</span>
<span class="postal-code">12345</span>
</div>
</div>"""
data = extruct.MicroformatExtractor().extract(html)
print(data)Scraping von Mikroformaten in Python
Sehen wir uns an, wie Sie Mikroformate für das Web-Scraping mithilfe der Python-Extruct-Bibliothek nutzen können. Wir werden Beispielseiten mithilfe der behandelten Techniken durchsuchen.
Installieren Sie extruct mit:
pip install extructScraping von JSON-LD:
import extruct
import requests
url = "https://example.com"
# Fetch HTML
response = requests.get(url)
html = response.text
# Extract JSON-LD
data = extruct.JsonLdExtractor().extract(html)
print(data)Dadurch werden alle in die Seite eingebetteten JSON-LD-Objekte ausgedruckt.
Ebenso können wir andere Formate scrapen:
# Microdata
data = extruct.MicrodataExtractor().extract(html)
# RDFa
data = extruct.RDFaExtractor().extract(html)
# OpenGraph
data = extruct.OpenGraphExtractor().extract(html)
# Microformat
data = extruct.MicroformatExtractor().extract(html)extruct verfügt außerdem über eine einheitliche Extraktionsmethode, die alle Formate auf einmal extrahiert:
import extruct
data = extruct.extract(html)
print(data.keys()) # ‘microdata‘, ‘json-ld‘, ‘opengraph‘, etc.Dies erleichtert das effiziente Scrapen mehrerer Mikroformate.
Beispiel für eine Scraping-Etsy-Produktseite
Sehen wir uns ein reales Beispiel für das Scrapen einer Etsy-Produktseite mithilfe von Mikroformaten an.
Wir verwenden die Etsy-Produkt-API, um Produkt-HTML abzurufen und zu extrahieren, um Mikroformate zu extrahieren.
import requests
import extruct
product_id = "1214112656"
# Fetch product HTML
url = f"https://www.etsy.com/listing/{product_id}"
response = requests.get(url)
html = response.text
# Extract all microformats
data = extruct.extract(html)
print(data.keys())
# Get JSON-LD product
product = next(obj for obj in data["json-ld"] if obj["@type"] == "Product")
# Print selected fields:
print(product["name"])
print(product["price"])
print(product["reviewCount"])Dadurch werden der Produktname, der Preis, die Anzahl der Bewertungen und andere aus JSON-LD extrahierte Felder ausgedruckt.
Wir können diese Techniken in einen vollständigen Web-Scraper für jede Website integrieren, die Mikroformate verwendet.
Tipps zum Schaben
Hier sind einige Tipps für effektives Mikroformat-Scraping:
Überprüfen Sie die Seitenquelle, um festzustellen, ob Mikroformate vorhanden sind. Konzentrieren Sie sich beim Scraping auf die am dichtesten besiedelten.
Für Websites wie Etsy enthält Product JSON-LD die besten Daten. OpenGraph ist nützlich für soziale Websites.
Normalisieren Sie die extrahierten Daten in reguläres JSON/Dicts, um die Verarbeitung zu erleichtern.
Erweitern Sie das Parsen mit BeautifulSoup oder ähnlichen Bibliotheken, wenn mehr Daten benötigt werden.
Verwenden Sie Proxys oder Tools wie Scrapfly, wenn die Site Scraping blockiert.
Mikroformate erleichtern das Abrufen strukturierter Daten von Webseiten. Durch die Integration in Ihre Scraper können Sie viel Aufwand beim Parsen von HTML sparen.
Zusammenfassung
Mikroformate wie JSON-LD, Microdata und RDFa stellen semantisch strukturierte Daten auf Webseiten zur einfachen Extraktion bereit.
Sie ermöglichen das Scrapen wichtiger Informationen wie Produkte, Artikel, Rezensionen, Personenprofile usw. ohne komplexe HTML-Analyse.
Indem wir diese Formate mithilfe der Extruct-Bibliothek identifizieren und extrahieren, können wir mit Python schneller skalierbare Web-Scraper erstellen.
Mikroformate decken nicht alle Daten ab, daher ist zusätzliches Parsen erforderlich. Aber sie bieten einen großen Vorsprung für robuste Schaber.
Ich hoffe, dieser Beitrag hat dazu beigetragen, den Wert des Scrapings von Mikroformaten für eine einfachere Extraktion von Webdaten zu verdeutlichen! Lassen Sie mich wissen, wenn Sie weitere Fragen haben.
