Rascunho da Web em Python: Automação eficiente da coleta de dados

Leia os termos de uso do conteúdo fornecido neste site

Ferramentas e suas características
Instalando o Python
Bibliotecas e ferramentas para raspagem da Web em Python
Exemplos de raspadores para sites estáticos e dinâmicos
Elementos HTML básicos
Escolhendo um site
Escolha de ferramentas para escrever o raspador e instalação
Encontrar elementos na página e escrever o raspador
Exemplo de raspador para um site dinâmico
Como salvar as informações extraídas?
Obstáculos na raspagem da Web
Recomendações para uma raspagem bem-sucedida
Conclusão

A raspagem da Web é um método de coleta de dados de sites. Ele permite extrair as informações necessárias para análise, monitoramento de preços, rastreamento de notícias e várias outras finalidades. Os raspadores ou analisadores da Web são ferramentas usadas para realizar a raspagem da Web. A linguagem mais conveniente e popular para escrever raspadores da Web é Python, embora quase qualquer linguagem possa ser usada para esse fim. Os usuários escolhem Python por vários motivos: sua sintaxe fácil, uma grande variedade de bibliotecas úteis para análise e suporte e atualizações constantes.

Neste guia, abordaremos as principais ferramentas de raspagem da Web e forneceremos um exemplo de implementação em Python. Com instruções passo a passo, você entenderá os conceitos básicos de raspagem e análise da Web, escreverá um script simples para coletar dados e aprenderá métodos para contornar vários obstáculos durante o processo.

Ferramentas e suas características

Escolhendo um IDE

Para trabalhar com eficiência, você precisa de um ambiente de desenvolvimento. A escolha de um ambiente adequado para raspagem da Web depende de vários fatores, como facilidade de uso, suporte às ferramentas necessárias, preferências pessoais e requisitos do projeto. Entre as ferramentas mais populares adequadas para a raspagem da Web em Python estão o PyCharm e o Visual Studio Code.

PyCharm
- Prós:
  - ID completo com muitos recursos.
  - Suporte para depuração, autocompletamento de código e gerenciamento de projetos.
  - Suporte para ambientes virtuais e integração com o Git.
- Cons:
  - Pode ser sobrecarregado para projetos pequenos.
  - Requer mais recursos em comparação com editores de texto.
- Visual Studio Code (VS Code)
  - Pros:
    - Ambiente leve e personalizável.
    - Uma ampla seleção de extensões para Python e raspagem da Web.
    - Suporte para depuração, Git e terminal.
  - Cons:
    - Pode exigir configuração para a funcionalidade completa do Python.
    - Podem ocorrer problemas de desempenho com um grande número de extensões.

Comece agora e automatize sua solução reCAPTCHA v2

Começar agora Demonstração

Instalando o Python

O Python também deve ser instalado em seu computador. Aqui está o guia de instalação para seu sistema operacional:

macOS: Faça o download da versão mais recente do Python no site oficial e siga as instruções do instalador.
Linux: O Python é pré-instalado em algumas distribuições do Linux (por exemplo, Ubuntu). Para verificar a versão do Python, execute o seguinte comando no terminal:
```
python --version
```
Se a versão do Python estiver desatualizada, instale a versão mais recente com este comando (exemplo para distribuições baseadas no Debian):
```
sudo apt-get update && sudo apt-get install python3
```
Windows: Visite o site do Python e faça o download da versão apropriada. Marque a caixa "Add python.exe to PATH" (Adicionar python.exe ao PATH) durante a instalação. Isso adicionará o Python ao PATH do sistema, facilitando o uso a partir da linha de comando.

Bibliotecas e ferramentas para raspagem da Web em Python

Agora, vamos dar uma olhada nas bibliotecas e ferramentas que tornarão mais conveniente escrever scripts para seu analisador. Abaixo estão as melhores opções, juntamente com suas características, para ajudá-lo a fazer a escolha certa para suas tarefas.

Requests: Uma biblioteca simples e conveniente para enviar solicitações HTTP. Ela recupera facilmente o código HTML das páginas da Web. Essa biblioteca é adequada para a maioria das tarefas padrão de raspagem da Web, especialmente se você não planeja executar um grande número de solicitações simultâneas. Ideal para raspagem de sites pequenos ou quando a execução assíncrona não é necessária.
Aiohttp: adequada para cenários mais complexos em que você precisa lidar com várias solicitações simultâneas e gerenciar tarefas assíncronas. Útil para trabalhar com grandes quantidades de dados e servidores em que a alta velocidade e a eficiência são importantes. Ideal para raspagem assíncrona da Web.
Lxml: Uma biblioteca flexível e altamente eficiente para processar documentos XML e HTML. Ela oferece recursos convenientes para trabalhar com esses documentos e oferece suporte a XPath e XSLT.
BeautifulSoup: Uma biblioteca para análise de documentos HTML e XML. Ela permite extrair dados do código HTML, estruturá-los e pode até mesmo processar HTML mal estruturado e corrigi-lo. A BeautifulSoup usa vários analisadores para analisar HTML e XML, como o html.parser incorporado no Python e analisadores de terceiros como lxml e html5lib, permitindo que você escolha o analisador mais adequado para a tarefa em questão.
Scrapy: Uma estrutura avançada para raspagem da Web e análise de dados que permite criar projetos para coletar, processar e salvar dados em vários formatos. O Scrapy é compatível com solicitações assíncronas, o que o torna muito rápido.
Selenium: Uma ferramenta para automatizar navegadores. Permite a interação com páginas da Web exatamente como um usuário, o que a torna ideal para trabalhar com sites dinâmicos. As vantagens do Selenium incluem o suporte a Python e JavaScript e a capacidade de simular ações do usuário.
Pyppeteer: Uma versão Python do Puppeteer (uma biblioteca Node.js) que automatiza o navegador Chromium para raspagem da Web. Permite a navegação na página, o preenchimento de formulários, o envio, os cliques em botões e outras ações rotineiras do usuário. O Pyppeteer também é útil para trabalhar com conteúdo dinâmico.
Playwright: Uma ferramenta avançada para automação do navegador que oferece suporte a várias linguagens (JavaScript/TypeScript, Python, .NET/C# e Java), é multithread e funciona com vários navegadores (Chromium, Firefox, WebKit). Ele pode ser instalado no Windows, macOS e Linux. O Playwright oferece alto desempenho e facilidade de uso para raspagem da Web e testes de aplicativos da Web.

Exemplos de raspadores para sites estáticos e dinâmicos

O que é HTML?

Antes de escrever qualquer raspador, você precisa entender os conceitos básicos de HTML e ser capaz de analisar a marcação do site para evitar se perder ao procurar elementos. HTML (HyperText Markup Language) é uma linguagem de marcação padrão usada para criar e estruturar páginas da Web. Ela descreve a estrutura do documento, incluindo texto, imagens, links e outros elementos exibidos no navegador.

Elementos HTML básicos

Tags: Um documento HTML consiste em várias tags que definem a estrutura e o conteúdo. Por exemplo:
- <html>: o elemento raiz de um documento HTML.
- <head>: Contém metadados como o título da página (<title>) e links para estilos.
- <body>: A parte principal do documento, contendo o conteúdo visível da página.
Elementos: Dentro das tags, pode haver elementos como:
- <h1>, <h2>, ..., <h6>: Cabeçalhos de vários níveis.
- <p>: Um parágrafo de texto.
- <a>: Um link.
- <img>: Uma imagem.
- <div>, <span>: Contêineres para agrupar outros elementos.
Atributos: as tags podem ter atributos que fornecem informações adicionais sobre o elemento. Por exemplo:
- <a href="https://example.com">: O atributo href especifica o URL de um link.
- <img src="image.jpg" alt="image description">: O atributo src especifica o caminho para a imagem e alt fornece um texto alternativo.

Escolhendo um site

Antes de selecionar as ferramentas apropriadas para escrever um scraper, você precisa estudar o site de destino e determinar se ele contém conteúdo dinâmico. Para fazer isso, carregue a página, abra a guia Network em Developer Tools e verifique se estão sendo feitas solicitações Fetch/XHR (essas tecnologias permitem que as páginas da Web atualizem dinamicamente o conteúdo com base nos dados recebidos do servidor):

Se não estiverem sendo feitas solicitações Fetch/XHR: você pode usar bibliotecas como BeautifulSoup e requests.

Se o site tiver conteúdo dinâmico: você deve usar ferramentas como Selenium ou Playwright para carregar as páginas da Web.

Para uma página estática de teste para extrair alguns dados, escolheremos https://quotes.toscrape.com/. Vamos escrever um raspador simples para extrair as três primeiras citações e seus autores.

Escolha de ferramentas para escrever o raspador e instalação

Para nossa finalidade, as bibliotecas BeautifulSoup e requests são suficientes. Vamos criar um novo arquivo no editor/IDE e adicionar as bibliotecas ao projeto usando o comando:

pip install beautifulsoup4 requests

BeautifulSoup facilita a pesquisa e a extração de dados:

Por Tags:

title_tag = soup.title
print(title_tag) # <title>Page Title</title>

Por texto: para extrair texto de uma tag, use o método .get_text():
```
header_text = soup.h1.get_text()
print(header_text) # Cabeçalho
```

Por Classes, IDs e Atributos:

elements = soup.find_all(class_='my-class')
element = soup.find(id='my-id')
links = soup.find_all('a', href=True)

Para consultas mais complexas: você pode usar seletores CSS com o método .select():
```
headers = soup.select('h1')
```

Encontrar elementos na página e escrever o raspador

Vamos retornar à página de destino, encontrar os elementos necessários e começar a escrever o código.

Abra o arquivo recém-criado e importe as bibliotecas instaladas anteriormente:

importar solicitações
from bs4 import BeautifulSoup

Especifique o URL da página necessária, defina o cabeçalho User-Agent para simular a atividade do navegador e envie uma solicitação GET para a página:

url = 'https://quotes.toscrape.com/'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/91.0.4472.124 Safari/537.36'
}

response = requests.get(url, headers=headers)

Verifique se a solicitação foi bem-sucedida:

if response.status_code == 200:
    # Crie um objeto BeautifulSoup para analisar o HTML
    soup = BeautifulSoup(response.text, 'html.parser')

Em uma janela separada do navegador com a página de destino aberta, localize todos os blocos com aspas, itere sobre os três primeiros blocos de aspas e extraia o texto da aspa em seu código:

Dica: Para pesquisar e analisar rapidamente as informações necessárias, passe o cursor sobre o elemento desejado, clique com o botão direito do mouse e selecione "Inspecionar". Isso abrirá o Developer Tools, onde você poderá visualizar o elemento na estrutura HTML da página e explorar outros elementos que ele possa conter. O destaque dos elementos selecionados facilita a tarefa.

citações = soup.select('.quote')
for quote in quotes[:3]:
   text = quote.select_one('.text').get_text(strip=True)

Extraia o nome do autor e imprima-o no console:

 author = quote.select_one('.author').get_text(strip=True)
    
    print(f'Quote: {text}\nAuthor: {author}\n')
else:
    print(f'Falha ao recuperar a página. Código de status: {response.status_code}')

Aqui está o código completo com explicações:

importar solicitações
from bs4 import BeautifulSoup

# URL da página a ser extraída
url = 'https://quotes.toscrape.com/'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/128.0.6613.85 Safari/537.36'
}

# Envie uma solicitação GET para a página com um agente de usuário
response = requests.get(url, headers=headers)

# Verificar se a solicitação foi bem-sucedida
if response.status_code == 200:
    # Crie um objeto BeautifulSoup para analisar o HTML
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # Encontre todos os blocos que contêm aspas
    quotes = soup.select('.quote')
    
    for quote in quotes[:3]:
        # Extraia o texto da citação
        text = quote.select_one('.text').get_text(strip=True)
        
        # Extrair o nome do autor
        author = quote.select_one('.author').get_text(strip=True)
        
        # Exibir as informações
        print(f'Citação: {texto}\nAutor: {autor}\n')
else:
    print(f'Failed to retrieve the page. Status code: {response.status_code}')

Quando você executar o código, seu coletor de dados exibirá as informações de que você precisa - as três primeiras citações e os nomes de seus autores.

from playwright.sync_api import sync_playwright url = 'https://parsemachine.com/sandbox/catalog/' def scrape_with_playwright(): with sync_playwright() as p: browser = p.chromium.launch(headless=False) page = browser.new_page() page.goto(url)

product_cards = page.query_selector_all('.card.product-card') for card in product_cards: title_tag = card.query_selector('.card-title .title') title = title_tag.inner_text() if title_tag else 'Nenhum título disponível'

from playwright.sync_api import sync_playwright # URL da página de destino url = 'https://parsemachine.com/sandbox/catalog/' def scrape_with_playwright(): with sync_playwright() as p: # Iniciar o navegador Chromium browser = p.chromium.launch(headless=False) # Alterar para True para o modo headless # Abrir uma nova guia page = browser.new_page() # Navegar para a página de destino page.goto(url) # Localizar todos os cartões de produto product_cards = page.query_selector_all('.card.product-card') for card in product_cards: # Extraia o título do produto title_tag = card.query_selector('.card-title .title') title = title_tag.inner_text() if title_tag else 'Nenhum título disponível' # Extraia o link do produto product_link = title_tag.get_attribute('href') if title_tag else 'Nenhum link disponível' # Se o link for relativo, adicione o URL de base if product_link and not product_link.startswith('http'): product_link = f'https://parsemachine.com{product_link}' # Imprima as informações do produto print(f'Title: {title}, Link: {product_link}') browser.close() scrape_with_playwright()

with open('quotes.csv', 'w', newline='', encoding='utf-8') as csvfile: csvwriter = csv.writer(csvfile) csvwriter.writerow(['Quote', 'Author']) for quote in quotes[:3]: text = quote.select_one('.text').get_text(strip=True) author = quote.select_one('.author').get_text(strip=True) csvwriter.writerow([text, author])

import requests from bs4 import BeautifulSoup import csv # URL da página de destino url = 'https://quotes.toscrape.com/' headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, como Gecko) Chrome/128.0.6613.85 Safari/537.36' } try: # Envie uma solicitação GET para a página com o agente do usuário response = requests.get(url, headers=headers) response.raise_for_status() # Verifique se há erros de HTTP # Crie um objeto BeautifulSoup para analisar o HTML soup = BeautifulSoup(response.text, 'html.parser') # Encontre todos os blocos com aspas quotes = soup.select('.quote') # Abra o arquivo CSV para gravação com open('quotes.csv', 'w', newline='', encoding='utf-8') as csvfile: # Crie um objeto escritor csvwriter = csv.writer(csvfile) # Escreva cabeçalhos csvwriter.writerow(['Quote', 'Author']) # Escreva dados de citação for quote in quotes[:3]: # Extrair o texto da citação text = quote.select_one('.text').get_text(strip=True) # Extrair o nome do autor author = quote.select_one('.author').get_text(strip=True) # Gravar no arquivo CSV csvwriter.writerow([text, author]) print("Data successfully written to quotes.csv") except requests.RequestException as e: print(f'Erro ao solicitar a página: {e}') except Exception as e: print(f'Ocorreu um erro: {e}')

from playwright.sync_api import sync_playwright import csv # URL da página de destino url = 'https://parsemachine.com/sandbox/catalog/' def scrape_with_playwright(): try: with sync_playwright() as p: # Inicia o navegador Chromium browser = p.chromium.launch(headless=False) # Altera para True para o modo headless try: # Abra uma nova guia page = browser.new_page() # Navegue até a página de destino page.goto(url) # Encontre todos os cartões de produto product_cards = page.query_selector_all('.card.product-card') # Abra o arquivo CSV para gravação com open('products.csv', 'w', newline='', encoding='utf-8') as csvfile: # Crie um objeto escritor csvwriter = csv.writer(csvfile) # Escreva cabeçalhos csvwriter.writerow(['Title', 'Link']) # Extraia dados dos cartões de produtos e escreva no CSV for card in product_cards: # Extraia o título do produto title_tag = card.query_selector('.card-title .title') title = title_tag.inner_text() if title_tag else 'Nenhum título disponível' # Link para a página do produto product_link = title_tag.get_attribute('href') if title_tag else 'Nenhum link disponível' # Se o link for relativo, adicione o URL de base if product_link and not product_link.startswith('http'): product_link = f'https://parsemachine.com{product_link}' # Grava os dados no arquivo CSV csvwriter.writerow([title, product_link]) # Imprime as informações do produto print(f'Title: {title}, Link: {product_link}') print("Data successfully written to products.csv") except Exception as e: print(f'Error working with Playwright: {e}') finally: # Feche o navegador browser.close() print("Browser closed.") except Exception as e: print(f'Error launching Playwright: {e}') scrape_with_playwright()