Web Scraping com Python: Extraindo Dados da Web | Data Driven School

Web Scraping com Python: Extraindo Dados da Web

07 de maio de 2025 11 min de leitura

O que é Web Scraping?

Web Scraping (ou raspagem de dados) é uma técnica utilizada para extrair informações de websites de forma automatizada. Em vez de copiar manualmente dados de diferentes páginas web, você pode criar scripts que navegam pelos sites, localizam as informações desejadas e as extraem de forma estruturada para análise posterior.

Como professor e consultor em ciência de dados, posso afirmar que o web scraping se tornou uma habilidade essencial para profissionais da área, permitindo a coleta de dados valiosos que não estão disponíveis através de APIs convencionais ou outras fontes estruturadas.

Por que Usar Web Scraping?

Existem diversas aplicações práticas para o web scraping:

  • Monitoramento de preços e produtos em e-commerces
  • Coleta de dados para pesquisas de mercado
  • Extração de contatos para geração de leads
  • Agregação de notícias e conteúdos de diferentes fontes
  • Coleta de dados para treinamento de modelos de machine learning
  • Monitoramento de mídias sociais e análise de sentimentos
  • Acompanhamento de informações financeiras e indicadores econômicos

A flexibilidade do web scraping permite que analistas e cientistas de dados acessem praticamente qualquer informação pública disponível na web, transformando-a em dados estruturados prontos para análise.

O Ecossistema Python para Web Scraping

Python se estabeleceu como a linguagem preferida para web scraping devido à sua sintaxe simples e ao rico ecossistema de bibliotecas. Vamos explorar as principais ferramentas disponíveis:

Requests: A Porta de Entrada para o Web Scraping

A biblioteca Requests é geralmente o ponto de partida para qualquer projeto de web scraping, pois permite fazer requisições HTTP de forma simples e elegante.

Características principais:

  • Sintaxe intuitiva para requisições GET, POST, PUT, DELETE, etc.
  • Suporte nativo para parâmetros de URL, cabeçalhos personalizados e cookies
  • Gerenciamento automático de redirecionamentos e conexões persistentes
  • Suporte a autenticação HTTP, SSL e proxy

Exemplo básico:

import requests

response = requests.get('https://exemplo.com.br')
html_content = response.text

print(f'Status: {response.status_code}')
print(html_content[:100])  # Primeiros 100 caracteres do HTML

Beautiful Soup: Navegando pelo HTML/XML

Após obter o conteúdo HTML com Requests, o Beautiful Soup permite navegar, buscar e modificar a árvore de análise do documento HTML ou XML, facilitando a extração de dados específicos.

Recursos principais:

  • Navegação intuitiva pela árvore DOM (Document Object Model)
  • Diversos métodos de busca: por tags, atributos, texto, CSS selectors, etc.
  • Correção automática de HTML mal formatado
  • Integração com diferentes parsers (html.parser, lxml, html5lib)

Exemplo prático:

from bs4 import BeautifulSoup

# Usando o HTML obtido anteriormente com Requests
soup = BeautifulSoup(html_content, 'html.parser')

# Encontrar todos os títulos h2
titles = soup.find_all('h2')
for title in titles:
    print(title.text.strip())

# Encontrar elementos por classe CSS
prices = soup.find_all('span', class_='price')
for price in prices:
    print(price.text)

Scrapy: Framework Completo para Web Scraping

Enquanto Requests + Beautiful Soup são ótimos para scripts simples, o Scrapy é um framework completo para projetos mais complexos e de grande escala, oferecendo uma arquitetura robusta.

Funcionalidades principais:

  • Sistema de extração baseado em seletores CSS e XPath
  • Gerenciamento automático de requisições e respostas
  • Pipeline de processamento de dados configurável
  • Middleware para autenticação, limitação de taxa, cache, etc.
  • Exportação de dados em diversos formatos (JSON, CSV, XML)
  • Shell interativo para desenvolvimento e debug

Estrutura básica de um spider Scrapy:

import scrapy

class ProdutosSpider(scrapy.Spider):
    name = 'produtos'
    start_urls = ['https://exemplo.com.br/produtos']
    
    def parse(self, response):
        for produto in response.css('div.produto'):
            yield {
                'nome': produto.css('h3.titulo::text').get(),
                'preco': produto.css('span.preco::text').get(),
                'disponivel': produto.css('span.status::text').get() == 'Em estoque'
            }
            
        # Seguir para a próxima página
        next_page = response.css('a.next::attr(href)').get()
        if next_page:
            yield response.follow(next_page, self.parse)

Selenium: Automatizando Interações com o Navegador

Para sites que dependem fortemente de JavaScript para renderizar conteúdo ou exigem interação do usuário, o Selenium permite controlar um navegador real para simular a navegação humana.

Recursos principais:

  • Controle programático de navegadores reais (Chrome, Firefox, etc.)
  • Suporte a ações como cliques, preenchimento de formulários, rolagem
  • Espera inteligente por elementos e carregamento de páginas
  • Captura de screenshots e gravação de vídeos
  • Execução em modo headless (sem interface gráfica) para maior performance

Exemplo de automação:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
import time

# Inicializar o navegador
driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))

# Navegar para a página
driver.get('https://exemplo.com.br/login')

# Preencher formulário de login
driver.find_element(By.ID, 'username').send_keys('meu_usuario')
driver.find_element(By.ID, 'password').send_keys('minha_senha')
driver.find_element(By.CSS_SELECTOR, 'button[type="submit"]').click()

# Esperar carregar a próxima página
time.sleep(2)

# Extrair conteúdo após o login
content = driver.find_element(By.CSS_SELECTOR, 'div.dashboard').text
print(content)

# Fechar o navegador
driver.quit()

LXML: Processamento Rápido de HTML/XML

A biblioteca lxml fornece processamento rápido e eficiente de HTML e XML, sendo especialmente útil para documentos grandes ou quando a performance é crítica.

Características principais:

  • Implementação completa de XPath 1.0
  • Suporte a seletores CSS
  • Validação de esquemas XML
  • Consumo de memória otimizado para arquivos grandes
  • Correção inteligente de HTML malformado

Exemplo básico:

from lxml import html
import requests

response = requests.get('https://exemplo.com.br')
tree = html.fromstring(response.content)

# Usando XPath para extrair informações
titles = tree.xpath('//h2/text()')
links = tree.xpath('//a/@href')

print(titles)
print(links)

PyQuery: A Sintaxe do jQuery para Python

Para desenvolvedores familiarizados com jQuery, o PyQuery oferece uma sintaxe semelhante para consultas HTML, facilitando a transição.

Vantagens principais:

  • Sintaxe inspirada no jQuery para manipulação de DOM
  • Seletores CSS semelhantes aos do jQuery
  • Métodos como find(), filter(), eq() e is()
  • Encadeamento de operações para consultas complexas

Exemplo de uso:

from pyquery import PyQuery as pq
import requests

response = requests.get('https://exemplo.com.br')
d = pq(response.text)

# Extrair informações usando sintaxe similar ao jQuery
titles = d('h2').text()
links = [a.attrib['href'] for a in d('a').items()]

print(titles)
print(links)

Bibliotecas Complementares para Web Scraping

Além das bibliotecas principais, existem ferramentas complementares que podem facilitar tarefas específicas:

Pandas: Para Armazenamento e Análise dos Dados

Após a extração, o Pandas é perfeito para armazenar, processar e analisar os dados coletados.

import pandas as pd

# Transformar dados extraídos em um DataFrame
products = [{'nome': 'Produto A', 'preco': 'R$ 99,90'}, {'nome': 'Produto B', 'preco': 'R$ 149,90'}]
df = pd.DataFrame(products)

# Limpar e processar os dados
df['preco'] = df['preco'].str.replace('R$ ', '').str.replace(',', '.').astype(float)

# Análise básica
print(df.describe())

# Exportar para CSV
df.to_csv('produtos.csv', index=False)

Fake UserAgent: Simulando Navegadores Reais

Para evitar bloqueios, é útil simular diferentes navegadores através do cabeçalho User-Agent:

from fake_useragent import UserAgent
import requests

ua = UserAgent()
headers = {'User-Agent': ua.random}

response = requests.get('https://exemplo.com.br', headers=headers)
print(response.status_code)

Playwright: Alternativa Moderna ao Selenium

O Playwright é uma alternativa mais recente e poderosa ao Selenium, desenvolvida pela Microsoft:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    
    page.goto('https://exemplo.com.br')
    page.fill('#searchbox', 'produto')
    page.click('#search-button')
    
    page.wait_for_selector('.results')
    results = page.inner_text('.results')
    
    browser.close()
    
print(results)

Desafios Comuns e Soluções

O web scraping apresenta diversos desafios técnicos e práticos. Vejamos alguns dos mais comuns e suas soluções:

1. Websites Dinâmicos com JavaScript

Muitos sites modernos carregam conteúdo dinamicamente via JavaScript, tornando-os inacessíveis para scrapers simples.

Soluções:

  • Usar Selenium ou Playwright para executar o JavaScript
  • Verificar se o site tem uma API interna que pode ser acessada diretamente
  • Analisar requisições AJAX no navegador e reproduzi-las com Requests
  • Utilizar ferramentas como Splash ou Puppeteer para renderizar JavaScript

2. Limitação de Taxa (Rate Limiting)

Sites podem bloquear IPs que fazem muitas requisições em curto período.

Estratégias para evitar bloqueios:

  • Adicionar delays aleatórios entre requisições (ex: 2-5 segundos)
  • Implementar back-off exponencial para retentativas
  • Usar proxies rotativas para distribuir requisições entre diferentes IPs
  • Respeitar o arquivo robots.txt e implementar limites de taxa razoáveis

3. CAPTCHAs e Verificações Anti-Bot

Sistemas como reCAPTCHA podem bloquear completamente scrapers automáticos.

Abordagens possíveis:

  • Usar serviços de resolução de CAPTCHA (2Captcha, Anti-Captcha, etc.)
  • Implementar fingerprinting de navegador para parecer mais humano
  • Considerar abordagens alternativas, como APIs oficiais quando disponíveis

4. Estruturas de Site em Constante Mudança

Alterações frequentes no HTML podem quebrar os scrapers existentes.

Soluções de manutenção:

  • Criar seletores robustos baseados em atributos estáveis
  • Implementar testes automáticos para detectar quebras
  • Usar XPaths relativos em vez de absolutos
  • Programar verificações periódicas para validar o funcionamento

Considerações Éticas e Legais

O web scraping é uma ferramenta poderosa, mas deve ser usado com responsabilidade. Aqui estão algumas considerações importantes:

1. Respeite os Termos de Serviço

Muitos sites proíbem explicitamente o scraping em seus termos de uso. Sempre leia e respeite essas políticas.

2. Obedeça ao arquivo robots.txt

Este arquivo indica quais partes de um site podem ser acessadas por bots. Respeitá-lo é uma prática padrão:

from urllib.robotparser import RobotFileParser

rp = RobotFileParser()
rp.set_url('https://exemplo.com.br/robots.txt')
rp.read()

can_scrape = rp.can_fetch('MyBot', '/produtos')
print(f'Permitido fazer scraping de /produtos: {can_scrape}')

3. Minimize o Impacto nos Servidores

Scrapers agressivos podem causar sobrecarga em servidores:

  • Implemente limites de taxa razoáveis
  • Evite requisições paralelas excessivas
  • Considere horários de menor tráfego para scraping em massa
  • Cache dados para evitar requisições repetidas

4. Proteja Dados Pessoais

Se você estiver coletando dados que podem incluir informações pessoais, certifique-se de estar em conformidade com regulamentos como LGPD e GDPR:

  • Não colete mais dados do que o necessário
  • Anonimize informações pessoais quando possível
  • Implemente medidas de segurança adequadas para armazenar os dados
  • Considere implicações de privacidade antes de publicar ou compartilhar dados

Implementando um Projeto Completo de Web Scraping

Vamos finalizar com um exemplo mais completo que combina várias bibliotecas para extrair informações de um site fictício de produtos:

import requests
from bs4 import BeautifulSoup
import pandas as pd
import time
import random
from urllib.parse import urljoin

# Configurações
base_url = 'https://exemplo.com.br/produtos'
num_pages = 3
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
}

# Lista para armazenar produtos
all_products = []

# Função para extrair detalhes de produto
def extract_product_details(product_url):
    # Adiciona delay aleatório para evitar bloqueios
    time.sleep(random.uniform(1, 3))
    
    response = requests.get(product_url, headers=headers)
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # Extrair detalhes
    try:
        name = soup.find('h1', class_='product-title').text.strip()
        price = soup.find('span', class_='price').text.strip()
        description = soup.find('div', class_='description').text.strip()
        availability = soup.find('span', class_='availability').text.strip()
        rating = soup.find('div', class_='rating').get('data-rating', 'N/A')
        
        # Extrair especificações técnicas
        specs = {}
        specs_table = soup.find('table', class_='specifications')
        if specs_table:
            rows = specs_table.find_all('tr')
            for row in rows:
                cols = row.find_all('td')
                if len(cols) == 2:
                    specs[cols[0].text.strip()] = cols[1].text.strip()
        
        return {
            'name': name,
            'price': price,
            'description': description,
            'availability': availability,
            'rating': rating,
            'url': product_url,
            **specs  # Adiciona especificações como colunas individuais
        }
    except Exception as e:
        print(f"Erro ao extrair detalhes de {product_url}: {e}")
        return None

# Iterar pelas páginas de resultados
for page in range(1, num_pages + 1):
    # Construir URL da página
    page_url = f"{base_url}?page={page}"
    print(f"Extraindo página {page}: {page_url}")
    
    # Obter HTML da página
    response = requests.get(page_url, headers=headers)
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # Encontrar todos os produtos na página
    product_cards = soup.find_all('div', class_='product-card')
    
    # Extrair URLs dos produtos
    product_urls = []
    for card in product_cards:
        link_element = card.find('a', class_='product-link')
        if link_element and 'href' in link_element.attrs:
            relative_url = link_element['href']
            full_url = urljoin(base_url, relative_url)
            product_urls.append(full_url)
    
    # Extrair detalhes de cada produto
    for url in product_urls:
        product_data = extract_product_details(url)
        if product_data:
            all_products.append(product_data)
    
    # Intervalo entre páginas
    if page < num_pages:
        time.sleep(random.uniform(2, 5))

# Converter para DataFrame e exportar
df = pd.DataFrame(all_products)

# Limpar dados
df['price'] = df['price'].str.replace('R$ ', '').str.replace('.', '').str.replace(',', '.').astype(float)

# Salvar em diferentes formatos
df.to_csv('produtos.csv', index=False)
df.to_excel('produtos.xlsx', index=False)

# Análise básica
print(f"Total de produtos coletados: {len(df)}")
print(f"Preço médio: R$ {df['price'].mean():.2f}")
print(f"Produto mais caro: {df.loc[df['price'].idxmax()]['name']} - R$ {df['price'].max():.2f}")
print(f"Produto mais barato: {df.loc[df['price'].idxmin()]['name']} - R$ {df['price'].min():.2f}")

Conclusão

O web scraping com Python é uma habilidade extremamente valiosa no arsenal de qualquer profissional de dados. Com as bibliotecas e técnicas apresentadas neste artigo, você tem um ponto de partida sólido para extrair dados estruturados da web e transformá-los em insights valiosos.

Lembre-se sempre de usar essas ferramentas de forma responsável, respeitando os termos de serviço dos sites, implementando boas práticas técnicas e considerando as implicações éticas e legais da coleta de dados.

Na Data Driven School, oferecemos cursos aprofundados sobre manipulação de dados com Python, incluindo técnicas avançadas de web scraping para análise de dados. Se você deseja aprimorar suas habilidades nessa área, confira nossos cursos de Python e análise de dados.

Você já implementou algum projeto de web scraping? Quais desafios encontrou? Compartilhe sua experiência nos comentários!

Análise de Dados Python SQL