Web Scraping semplificato: scraping di microformati
Introduzione
Il web scraping è il processo di estrazione automatica dei dati dai siti Web. Si tratta di scrivere programmi in grado di comprendere le strutture delle pagine Web ed estrarre le informazioni rilevanti. Sebbene il web scraping possa essere impegnativo per i siti Web complessi, esistono alcune tecniche che semplificano il lavoro. Una di queste tecniche è lo scraping dei microformati.
I microformati forniscono metadati semantici incorporati nel codice HTML in modo standardizzato. Rendono più semplice per i programmi estrarre informazioni significative dalle pagine web. In questa guida impareremo le basi dei microformati, i tipi più diffusi e come sfruttarli per il web scraping senza sforzo utilizzando Python.
Cosa sono i microformati?
I microformati sono stati creati per standardizzare la rappresentazione di importanti oggetti di dati web in modo che possano essere leggibili dalle macchine. Più comunemente, i microformati vengono utilizzati per creare schede di anteprima per le pagine Web. Sono più comunemente utilizzati per fornire visualizzazioni di dati per motori di ricerca, social network e altri canali di comunicazione.
Ad esempio, quando pubblichi un collegamento sui social media o su Slack, viene visualizzata una scheda di anteprima con titolo, descrizione e miniatura. Questo viene generato estraendo microformati da quella pagina.
L'unico svantaggio è che i microformati non contengono l'intero set di dati della pagina. Potrebbe essere necessario estendere il parser del microformato con l'analisi HTML utilizzando strumenti come Beautiful Soup o il selettore CSS e i parser XPath.
Tipi di microformati più diffusi
Esistono diversi standard di microformato utilizzati sul Web. Esploriamo alcuni tipi popolari e come estrarli utilizzando la libreria di estrusione Python.
JSON-LD
JSON-LD è il microformato moderno più popolare. Utilizza documenti JSON incorporati che rappresentano direttamente gli oggetti schema.org.
Ecco un esempio di markup JSON-LD e come analizzarlo utilizzando 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)Questo restituisce un oggetto Persona JSON-LD con campi schema.org come nome, immagine, jobTitle ecc.
JSON-LD è facile da implementare ma può non corrispondere ai dati della pagina poiché è separato dai dati visibili.
Microdata
I microdati sono il secondo formato più popolare che utilizza attributi HTML per contrassegnare i campi di microformato. Questo è ottimo per il web scraping poiché copre i dati delle pagine visibili.
Ecco un esempio e come analizzarlo:
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)I microdati corrispondono più fedelmente ai dati di origine poiché utilizzano gli stessi dati visualizzati nella pagina.
RDFa
RDFa è simile ai microdati che utilizza attributi HTML per i microformati. Condivide gli stessi vantaggi dei Microdata.
Ecco un esempio:
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)I dati RDFa corrispondono alla fonte reale ma l'output è un po' contorto.
OpenGraph
OpenGraph di Facebook viene utilizzato per generare schede di anteprima nei post social. Supporta gli oggetti schema.org ma viene utilizzato raramente oltre le anteprime del sito Web.
Ecco un esempio:
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 può differire dai dati della pagina poiché non fa parte della pagina naturale.
Microformato
Il microformato è uno dei formati più antichi che precede schema.org con i propri schemi per persone, organizzazioni, eventi, prodotti ecc.
Ecco un esempio:
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 di microformati in Python
Vediamo come sfruttare i microformati per il web scraping utilizzando la libreria di estrusione Python. Analizzeremo i siti campione utilizzando le tecniche descritte.
Installa l'estrazione utilizzando:
pip install extructScraping 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)Questo stamperà tutti gli oggetti JSON-LD incorporati nella pagina.
Allo stesso modo, possiamo raschiare altri formati:
# 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 ha anche un metodo di estrazione unificato che estrae tutti i formati contemporaneamente:
import extruct
data = extruct.extract(html)
print(data.keys()) # ‘microdata‘, ‘json-ld‘, ‘opengraph‘, etc.Ciò semplifica lo scraping di più microformati in modo efficiente.
Esempio di scraping della pagina del prodotto Etsy
Vediamo un esempio reale raschiando una pagina di prodotto Etsy utilizzando i microformati.
Utilizzeremo l'API del prodotto Etsy per recuperare l'HTML del prodotto ed estrarlo per estrarre i microformati.
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"])Questo stampa il nome del prodotto, il prezzo, il conteggio delle recensioni e altri campi estratti da JSON-LD.
Possiamo integrare queste tecniche in un web scraper completo per qualsiasi sito che utilizza microformati.
Suggerimenti per la raschiatura
Ecco alcuni suggerimenti per un efficace scraping dei microformati:
Esamina l'origine della pagina per verificare se sono presenti microformati. Concentrati sul raschiamento su quelli più popolati.
Per siti come Etsy, il prodotto JSON-LD contiene i dati migliori. OpenGraph è utile per i siti social.
Normalizza i dati estratti in JSON/dict regolari per facilitarne l'elaborazione.
Estendi l'analisi con BeautifulSoup o librerie simili se sono necessari più dati.
Utilizza proxy o strumenti come Scrapfly se il sito blocca lo scraping.
I microformati facilitano l'ottenimento di dati strutturati dalle pagine web. Integrarli nei tuoi scraper può farti risparmiare molto sforzo nell'analisi dell'HTML.
Sommario
Microformati come JSON-LD, Microdata e RDFa forniscono dati strutturati semantici sulle pagine Web per una facile estrazione.
Consentono di raccogliere informazioni chiave come prodotti, articoli, recensioni, profili di persone, ecc. Senza una complessa analisi HTML.
Identificando ed estraendo questi formati utilizzando la libreria extruct, possiamo creare web scraper scalabili più velocemente con Python.
I microformati non copriranno tutti i dati, quindi è necessaria un'ulteriore analisi. Ma forniscono un ottimo vantaggio per i raschiatori robusti.
Spero che questo post abbia contribuito a spiegare il valore dello scraping dei microformati per una più semplice estrazione dei dati web! Fatemi sapere se avete altre domande.
