Web Scraping simplifié – Scraping de microformats
Introduction
Le Web scraping est le processus d’extraction automatique des données des sites Web. Cela implique l’écriture de programmes capables de comprendre les structures des pages Web et d’extraire les informations pertinentes. Bien que le web scraping puisse être difficile pour les sites Web complexes, certaines techniques facilitent le travail. L’une de ces techniques consiste à gratter les microformats.
Les microformats fournissent des métadonnées sémantiques intégrées au code HTML de manière standardisée. Ils permettent aux programmes d’extraire plus facilement des informations significatives des pages Web. Dans ce guide, nous apprendrons les bases des microformats, les types populaires et comment les exploiter pour un web scraping sans effort à l'aide de Python.
Que sont les microformats ?
Les microformats ont été créés pour normaliser la représentation des objets de données Web importants afin qu'ils puissent être lisibles par machine. Le plus souvent, les microformats sont utilisés pour créer des cartes d'aperçu pour les pages Web. Ils sont le plus souvent utilisés pour fournir des vues de données aux moteurs de recherche, aux réseaux sociaux et à d’autres canaux de communication.
Par exemple, lorsque vous publiez un lien sur les réseaux sociaux ou sur Slack, une carte d'aperçu avec un titre, une description et une vignette s'affiche. Ceci est généré en grattant les microformats de cette page.
Le seul inconvénient est que les microformats ne contiennent pas l'ensemble des données de la page. Nous devrons peut-être étendre l'analyseur microformat avec l'analyse HTML à l'aide d'outils tels que Beautiful Soup ou le sélecteur CSS et les analyseurs XPath.
Types de microformats populaires
Il existe plusieurs standards de microformat utilisés sur le Web. Explorons quelques types populaires et comment les extraire à l'aide de la bibliothèque d'extraits Python.
JSON-LD
JSON-LD est le microformat moderne le plus populaire. Il utilise des documents JSON intégrés qui représentent directement les objets schema.org.
Voici un exemple de balisage JSON-LD et comment l'analyser à l'aide d'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)Cela génère un objet JSON-LD Person avec des champs schema.org tels que nom, image, jobTitle, etc.
JSON-LD est facile à mettre en œuvre mais peut ne pas correspondre aux données de page car elles sont distinctes des données visibles.
Microdonnées
Les microdonnées sont le deuxième format le plus populaire utilisant des attributs HTML pour baliser les champs du microformat. C'est idéal pour le web scraping car il couvre les données de page visibles.
Voici un exemple et comment l'analyser :
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)Les microdonnées correspondent plus étroitement aux données sources car elles utilisent les mêmes données affichées sur la page.
RDFa
RDFa est similaire à Microdata utilisant des attributs HTML pour les microformats. Il partage les mêmes avantages que les microdonnées.
Voici un exemple :
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)Les données RDFa correspondent à la source réelle mais la sortie est un peu alambiquée.
OpenGraph
OpenGraph de Facebook est utilisé pour générer des cartes d'aperçu dans les publications sociales. Il prend en charge les objets schema.org mais est rarement utilisé au-delà des aperçus de sites Web.
Voici un exemple :
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 peut différer des données de page car il ne fait pas partie de la page naturelle.
Microformat
Le microformat est l'un des formats les plus anciens, antérieur à schema.org, avec ses propres schémas pour les personnes, les organisations, les événements, les produits, etc.
Voici un exemple :
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)Scraper des microformats en Python
Voyons comment exploiter les microformats pour le web scraping à l'aide de la bibliothèque d'extraits Python. Nous explorerons des exemples de sites en utilisant les techniques décrites.
Installez l'extrait en utilisant :
pip install extructGrattage de 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)Cela imprimera tous les objets JSON-LD intégrés dans la page.
De même, on peut scraper d’autres formats :
# 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 dispose également d'une méthode d'extraction unifiée qui extrait tous les formats à la fois :
import extruct
data = extruct.extract(html)
print(data.keys()) # ‘microdata‘, ‘json-ld‘, ‘opengraph‘, etc.Cela facilite le scraping efficace de plusieurs microformats.
Exemple de page produit Etsy de grattage
Voyons un exemple réel de scraping d'une page de produit Etsy à l'aide de microformats.
Nous utiliserons l'API du produit Etsy pour récupérer le code HTML du produit et l'extraire pour extraire les microformats.
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"])Ceci imprime le nom du produit, le prix, le nombre d'avis et d'autres champs extraits de JSON-LD.
Nous pouvons intégrer ces techniques dans un scraper web complet pour tout site utilisant des microformats.
Conseils de grattage
Voici quelques conseils pour un scraping efficace des microformats :
Inspectez la source de la page pour déterminer si des microformats sont présents. Concentrez-vous sur les plus peuplés.
Pour des sites comme Etsy, Product JSON-LD contient les meilleures données. OpenGraph est utile pour les sites sociaux.
Normalisez les données extraites en JSON/dicts standards pour faciliter leur traitement.
Étendez l'analyse avec BeautifulSoup ou des bibliothèques similaires si plus de données sont nécessaires.
Utilisez des proxys ou des outils comme Scrapfly si le site bloque le scraping.
Les microformats facilitent l'obtention de données structurées à partir de pages Web. Les intégrer dans vos scrapers peut vous faire économiser beaucoup d’efforts lors de l’analyse du HTML.
Résumé
Les microformats comme JSON-LD, Microdata et RDFa fournissent des données sémantiques structurées sur les pages Web pour une extraction facile.
Ils permettent de récupérer des informations clés telles que des produits, des articles, des critiques, des profils de personnes, etc. sans analyse HTML complexe.
En identifiant et en extrayant ces formats à l'aide de la bibliothèque extruct, nous pouvons créer plus rapidement des scrapers Web évolutifs avec Python.
Les microformats ne couvrent pas toutes les données, une analyse supplémentaire est donc nécessaire. Mais ils constituent une excellente longueur d’avance pour les grattoirs robustes.
J'espère que cet article a aidé à expliquer l'intérêt du scraping des microformats pour une extraction plus facile des données Web ! Faites-moi savoir si vous avez d'autres questions.
