Webscrapen vereenvoudigd – Microformaten schrapen
Introductie
Webscrapen is het proces waarbij automatisch gegevens van websites worden geëxtraheerd. Het gaat om het schrijven van programma's die webpaginastructuren kunnen begrijpen en de relevante informatie kunnen extraheren. Hoewel webscrapen een uitdaging kan zijn voor complexe websites, zijn er bepaalde technieken die het werk gemakkelijker maken. Eén van die technieken is het schrapen van microformaten.
Microformaten bieden semantische metadata die op een gestandaardiseerde manier in de HTML-code zijn ingebed. Ze maken het voor programma's gemakkelijker om betekenisvolle informatie uit webpagina's te halen. In deze handleiding leren we de basisprincipes van microformaten, de populaire typen, en hoe we deze kunnen gebruiken voor moeiteloos webscrapen met Python.
Wat zijn microformaten?
Er zijn microformaten gemaakt om de weergave van belangrijke webgegevensobjecten te standaardiseren, zodat ze machinaal leesbaar kunnen zijn. Meestal worden microformaten gebruikt om voorbeeldkaarten voor webpagina's te maken. Ze worden meestal gebruikt om gegevensweergaven te bieden voor zoekmachines, sociale netwerken en andere communicatiekanalen.
Wanneer u bijvoorbeeld een link op sociale media of Slack plaatst, wordt er een voorbeeldkaart weergegeven met titel, beschrijving en miniatuur. Dit wordt gegenereerd door microformaten van die pagina te schrapen.
Het enige nadeel is dat microformaten niet de hele paginadataset bevatten. Mogelijk moeten we de microformat-parser uitbreiden met HTML-parsing met behulp van tools zoals Beautiful Soup of CSS-selector en XPath-parsers.
Populaire microformattypen
Er worden op internet verschillende microformatstandaarden gebruikt. Laten we enkele populaire typen verkennen en zien hoe u deze kunt extraheren met behulp van de Python-extractbibliotheek.
JSON-LD
JSON-LD is het populairste moderne microformaat. Het maakt gebruik van ingebedde JSON-documenten die rechtstreeks schema.org-objecten vertegenwoordigen.
Hier is een voorbeeld van JSON-LD-opmaak en hoe u deze kunt parseren met behulp van extruct:
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)Dit levert een JSON-LD Person-object op met schema.org-velden zoals naam, afbeelding, jobTitle enz.
JSON-LD is eenvoudig te implementeren, maar kan paginagegevens niet matchen omdat deze gescheiden zijn van zichtbare gegevens.
microdata
Microdata is het op een na populairste formaat dat HTML-attributen gebruikt om microformatvelden te markeren. Dit is geweldig voor webscrapen omdat het zichtbare paginagegevens bedekt.
Hier is een voorbeeld en hoe je het kunt parseren:
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)Microdata komt nauwer overeen met de brongegevens, omdat het dezelfde gegevens gebruikt die op de pagina worden weergegeven.
RDFa
RDFa is vergelijkbaar met Microdata en gebruikt HTML-attributen voor microformaten. Het deelt dezelfde voordelen als Microdata.
Hier is een voorbeeld:
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-gegevens komen overeen met de echte bron, maar de uitvoer is een beetje ingewikkeld.
OpenGraph
Facebook's OpenGraph wordt gebruikt om voorbeeldkaarten in sociale berichten te genereren. Het ondersteunt schema.org-objecten, maar wordt zelden gebruikt buiten websitevoorbeelden.
Hier is een voorbeeld:
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 kan verschillen van paginagegevens omdat het geen deel uitmaakt van de natuurlijke pagina.
Microformaat
Microformat is een van de oudste formaten die dateert van vóór schema.org, met eigen schema's voor mensen, organisaties, evenementen, producten enz.
Hier is een voorbeeld:
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)Microformaten schrapen in Python
Laten we eens kijken hoe we microformaten kunnen gebruiken voor webscrapen met behulp van de Python-extractbibliotheek. We zullen voorbeeldsites schrapen met behulp van de behandelde technieken.
Installeer extract met behulp van:
pip install extructJSON-LD schrapen:
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)Hiermee worden alle JSON-LD-objecten afgedrukt die in de pagina zijn ingebed.
Op dezelfde manier kunnen we andere formaten schrapen:
# Microdata
data = extruct.MicrodataExtractor().extract(html)
# RDFa
data = extruct.RDFaExtractor().extract(html)
# OpenGraph
data = extruct.OpenGraphExtractor().extract(html)
# Microformat
data = extruct.MicroformatExtractor().extract(html)extruc heeft ook een uniforme extractiemethode die alle formaten in één keer extraheert:
import extruct
data = extruct.extract(html)
print(data.keys()) # ‘microdata‘, ‘json-ld‘, ‘opengraph‘, etc.Dit maakt het eenvoudig om meerdere microformaten efficiënt te schrapen.
Voorbeeld van een Etsy-productpagina schrapen
Laten we een echt voorbeeld bekijken van het scrapen van een Etsy-productpagina met behulp van microformaten.
We gebruiken de Etsy-product-API om product-HTML op te halen en te extraheren om microformaten te extraheren.
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"])Hiermee worden de productnaam, prijs, het aantal recensies en andere velden uit JSON-LD afgedrukt.
We kunnen deze technieken integreren in een volledige webschraper voor elke site die microformaten gebruikt.
Schraaptips
Hier zijn enkele tips voor effectief schrapen van microformaten:
Inspecteer de paginabron om te zien of er microformaten aanwezig zijn. Focus op het schrapen van de meest bevolkte gebieden.
Voor sites als Etsy bevat Product JSON-LD de beste gegevens. OpenGraph is handig voor sociale sites.
Normaliseer de geëxtraheerde gegevens in reguliere JSON/dicts om de verwerking ervan te vergemakkelijken.
Breid het parseren uit met BeautifulSoup of soortgelijke bibliotheken als er meer gegevens nodig zijn.
Gebruik proxy's of tools zoals Scrapfly als de site scraping blokkeert.
Microformaten maken het gemakkelijk om gestructureerde gegevens uit webpagina's te halen. Door ze in uw scrapers te integreren, kunt u veel moeite besparen bij het parseren van HTML.
Samengevat
Microformaten zoals JSON-LD, Microdata en RDFa bieden semantisch gestructureerde gegevens op webpagina's voor eenvoudige extractie.
Ze maken het mogelijk belangrijke informatie zoals producten, artikelen, recensies, persoonsprofielen, enz. te verzamelen zonder complexe HTML-parsering.
Door deze formaten te identificeren en te extraheren met behulp van de extructuurbibliotheek, kunnen we sneller schaalbare webschrapers bouwen met Python.
Microformaten dekken niet alle gegevens, dus er is extra parsering nodig. Maar ze bieden een geweldige voorsprong voor robuuste schrapers.
Ik hoop dat dit bericht heeft geholpen de waarde van het schrapen van microformaten voor eenvoudigere extractie van webgegevens uit te leggen! Laat het me weten als je nog vragen hebt.
