Web Scraping simplificado – Scraping de microformatos
Introdução
Web scraping é o processo de extração automática de dados de sites. Envolve escrever programas que possam compreender as estruturas das páginas da web e extrair as informações relevantes. Embora o web scraping possa ser um desafio para sites complexos, existem certas técnicas que tornam o trabalho mais fácil. Uma dessas técnicas é a raspagem de microformatos.
Os microformatos fornecem metadados semânticos incorporados ao código HTML de forma padronizada. Eles tornam mais fácil para os programas extrair informações significativas de páginas da web. Neste guia, aprenderemos os fundamentos dos microformatos, os tipos populares e como aproveitá-los para web scraping sem esforço usando Python.
O que são microformatos?
Os microformatos foram criados para padronizar a representação de importantes objetos de dados da web para que possam ser legíveis por máquina. Mais comumente, os microformatos são usados para criar cartões de visualização de páginas da web. Eles são mais comumente usados para fornecer visualizações de dados para mecanismos de pesquisa, redes sociais e outros canais de comunicação.
Por exemplo, quando você publica um link nas redes sociais ou no Slack, ele exibe um cartão de visualização com título, descrição e miniatura. Isso é gerado pela extração de microformatos dessa página.
A única desvantagem é que os microformatos não contêm todo o conjunto de dados da página. Podemos precisar estender o analisador de microformato com análise de HTML usando ferramentas como Beautiful Soup ou seletor CSS e analisadores XPath.
Tipos populares de microformatos
Existem vários padrões de microformato usados na web. Vamos explorar alguns tipos populares e como extraí-los usando a biblioteca de extrusão Python.
JSON-LD
JSON-LD é o microformato moderno mais popular. Ele usa documentos JSON incorporados que representam diretamente objetos do schema.org.
Aqui está um exemplo de marcação JSON-LD e como analisá-la usando 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)Isso gera um objeto JSON-LD Person com campos do schema.org como nome, imagem, jobTitle etc.
JSON-LD é fácil de implementar, mas pode não corresponder aos dados da página, pois é separado dos dados visíveis.
Microdados
Microdados é o segundo formato mais popular que usa atributos HTML para marcar campos de microformato. Isso é ótimo para web scraping, pois cobre dados de páginas visíveis.
Aqui está um exemplo e como analisá-lo:
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)Os microdados correspondem mais de perto aos dados de origem, pois usam os mesmos dados exibidos na página.
RDFa
RDFa é semelhante aos microdados usando atributos HTML para microformatos. Ele compartilha as mesmas vantagens dos microdados.
Aqui está um exemplo:
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)Os dados RDFa correspondem à fonte real, mas a saída é um pouco complicada.
OpenGraph
O OpenGraph do Facebook é usado para gerar cartões de visualização em postagens sociais. Ele oferece suporte a objetos schema.org, mas raramente é usado além das visualizações do site.
Aqui está um exemplo:
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) O Opengraph pode ser diferente dos dados da página porque não faz parte da página natural.
Microformato
Microformato é um dos formatos mais antigos anteriores ao schema.org com seus próprios esquemas para pessoas, organizações, eventos, produtos, etc.
Aqui está um exemplo:
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)Raspando microformatos em Python
Vamos ver como aproveitar microformatos para web scraping usando a biblioteca extruct Python. Rastrearemos sites de amostra usando as técnicas abordadas.
Instale a extração usando:
pip install extructRaspando 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)Isso imprimirá todos os objetos JSON-LD incorporados na página.
Da mesma forma, podemos copiar outros formatos:
# 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 também possui um método de extração unificado que extrai todos os formatos de uma vez:
import extruct
data = extruct.extract(html)
print(data.keys()) # ‘microdata‘, ‘json-ld‘, ‘opengraph‘, etc.Isso facilita a raspagem eficiente de vários microformatos.
Exemplo de página de produto de raspagem do Etsy
Vamos ver um exemplo real de raspagem de uma página de produto Etsy usando microformatos.
Usaremos a API do produto Etsy para buscar o HTML do produto e extrair para extrair microformatos.
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"])Isso imprime o nome do produto, preço, contagem de avaliações e outros campos extraídos do JSON-LD.
Podemos integrar essas técnicas em um web scraper completo para qualquer site que use microformatos.
Dicas de raspagem
Aqui estão algumas dicas para uma raspagem eficaz de microformatos:
Inspecione o código-fonte da página para descobrir se há algum microformato presente. Concentre a raspagem nos mais populosos.
Para sites como o Etsy, o produto JSON-LD contém os melhores dados. OpenGraph é útil para sites sociais.
Normalize os dados extraídos em JSON/dictos regulares para facilitar o processamento.
Estenda a análise com BeautifulSoup ou bibliotecas semelhantes se forem necessários mais dados.
Use proxies ou ferramentas como Scrapfly se o site bloquear a raspagem.
Os microformatos facilitam a obtenção de dados estruturados de páginas da web. Integrá-los em seus scrapers pode economizar muito esforço na análise de HTML.
Resumo
Microformatos como JSON-LD, Microdata e RDFa fornecem dados semânticos estruturados em páginas da web para fácil extração.
Eles permitem extrair informações importantes, como produtos, artigos, avaliações, perfis de pessoas, etc., sem análise complexa de HTML.
Ao identificar e extrair esses formatos usando a biblioteca extruct, podemos construir web scrapers escaláveis mais rapidamente com Python.
Os microformatos não cobrem todos os dados, portanto é necessária uma análise adicional. Mas eles fornecem um grande avanço para raspadores robustos.
Espero que esta postagem tenha ajudado a explicar o valor da raspagem de microformatos para facilitar a extração de dados da web! Deixe-me saber se você tem alguma dúvida.
