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

/

/

/

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

Ekaterina Yanchuk

Autor de artigos técnicos

May 20, 2026

16 min

Web scraping em Python: automação eficiente da coleta de dados

Por favor, leia as regras de uso dos materiais deste recurso

Web scraping é um método de coleta de dados de sites. Ele permite extrair informações necessárias para análise, monitoramento de preços, acompanhamento de notícias e outros diversos objetivos. Web scrapers ou parsers são ferramentas usadas para realizar web scraping. A linguagem mais conveniente e popular para escrever web scrapers é Python, embora praticamente qualquer linguagem possa ser usada para essa finalidade. Os usuários escolhem Python por várias razões: sintaxe simples, muitas bibliotecas úteis para parsing, suporte contínuo e atualizações.

Neste guia, vamos analisar as principais ferramentas para web scraping e fornecer um exemplo de implementação em Python. Com instruções passo a passo, você poderá entender os fundamentos de web scraping e parsing, escrever um script simples para coleta de dados, além de aprender métodos para contornar diferentes obstáculos durante o processo.

ItGuy

Programa de afiliados para desenvolvedores de software

Ganhe até 30% dos gastos dos seus usuários com a evasão de captcha

✅ Solicitação enviada

Obrigado pelo seu interesse em nosso programa de parcerias! Entraremos em contato com você dentro de 7 dias úteis.

Solicitação para participar

Preencha o formulário para enviar uma solicitação para o programa de afiliados.

Mais artigos

As 5 melhores linguagens de programação para Web Scraping

As 5 melhores linguagens de programação para Web Scraping

A coleta de grandes quantidades de dados para análise posterior, previsão, monitoramento e uma série de outras tarefas tornou-se um dos pilares de muitos setores.

November 28, 2024

Por que o CAPTCHA não está funcionando? Causas comuns e como corrigir

Por que o CAPTCHA não está funcionando? Causas comuns e como corrigir

Instalação do Python

Também é necessário ter o Python instalado no seu computador. Instruções de instalação para o seu sistema operacional:

macOS

Para instalar a versão mais recente do Python, acesse o link , baixe o instalador e siga as instruções:

Linux

Em algumas distribuições Linux (por exemplo, Ubuntu), o Python já vem pré-instalado. Para verificar a versão do Python, execute no terminal o seguinte comando:

python --version

A versão do Python pode estar desatualizada; nesse caso, instalar a versão mais recente pode ser feito com o seguinte comando (exemplo para distribuições Debian):

sudo apt-get update && sudo apt-get install python3

Windows

Acesse a página do Python e baixe a versão adequada. Marque a opção "Add python.exe to PATH". Isso adicionará o Python ao PATH do sistema, facilitando seu uso pela linha de comando.

Seleção de ferramentas para escrever o scraper, instalação

Para o nosso objetivo, as bibliotecas BeautifulSoup e requests são perfeitamente adequadas. Vamos criar um novo arquivo no editor/IDE e adicionar as bibliotecas ao projeto com o comando:

pip install beautifulsoup4 requests

BeautifulSoup realiza a busca e 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)  # Header

Por classes, identificadores 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')

Busca de elementos na página, escrita do scraper

Voltamos à página alvo, encontramos os elementos necessários e começamos a escrever o código.

Abrimos o novo arquivo criado e importamos as bibliotecas previamente instaladas:

import requests
from bs4 import BeautifulSoup

Definimos a URL da página desejada, configuramos o cabeçalho User-Agent para simular um navegador e enviamos uma requisiçã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, like Gecko) Chrome/147.0.0.0 Safari/537.36'
}
response = requests.get(url, headers=headers)

Verificamos se a requisição foi bem-sucedida:

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

No navegador aberto na página desejada, procuramos os blocos de citações, percorremos os três primeiros blocos e extraímos o texto das citações no nosso código:

Para uma busca rápida e análise da informação necessária, passe o cursor sobre o elemento desejado, clique com o botão direito e selecione 'Inspect'. Isso abrirá as Ferramentas de Desenvolvedor, onde você poderá visualizar o elemento na estrutura HTML da página e também explorar outros elementos dentro dos quais ele pode estar inserido. O realce dos elementos selecionados facilita a análise.


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

Extraímos o nome do autor e imprimimos no console:

        author = quote.select_one('.author').get_text(strip=True)
 
        print(f'Citação: {text}\nAutor: {author}\n')
else:
    print(f'Não foi possível obter a página. Código de status: {response.status_code}')

Código final com explicações:

import requests
from bs4 import BeautifulSoup

url = 'https://quotes.toscrape.com/'
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36'
}

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

if response.status_code == 200:
    soup = BeautifulSoup(response.text, 'html.parser')
    
    quotes = soup.select('.quote')
    
    for quote in quotes[:3]:
        text = quote.select_one('.text').get_text(strip=True)
        
        author = quote.select_one('.author').get_text(strip=True)
        
        print(f'Citação: {text}\nAutor: {author}\n')
else:
    print(f'Não foi possível obter a página. Código de status: {response.status_code}')

Ao executar o código, o scraper exibirá as informações necessárias — as três primeiras citações e os nomes de seus autores:

Exemplo de scraper para site dinâmico

Como exemplo de site dinâmico, vamos usar o https://parsemachine.com. Em particular, escolhemos a página de teste https://parsemachine.com/sandbox/catalog/, onde há cartões com 12 produtos. Vamos tentar extrair o nome de cada produto e o link para ele. Como o site é dinâmico, usaremos o Playwright. Esta ferramenta de automação de navegador encontra e extrai elementos em páginas web usando seletores CSS e XPath, seletores de texto e ARIA, além de suportar a combinação de seletores para uma escolha precisa.

Criamos um novo projeto, instalamos o Playwright e o navegador Chromium com os comandos:

pip install playwright
playwright install chromium

Encontramos os elementos desejados usando as Ferramentas de desenvolvedor:

Importamos o Playwright, iniciamos o navegador e acessamos a página desejada:

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)

No nosso exemplo, o uso do método síncrono é suficiente. No entanto, a abordagem assíncrona tem suas vantagens, especialmente em tarefas de I/O, como requisições de rede e interação com páginas web. Ela permite executar várias operações em paralelo sem bloquear o fluxo principal de execução. Isso é especialmente útil quando é necessário raspar muitas páginas ao mesmo tempo. Também permite que o programa continue executando outras tarefas enquanto aguarda a resposta do servidor, melhorando a responsividade geral da aplicação. Para o método assíncrono, use async_playwright() em vez de sync_playwright() e adicione await ao seu código. Também podem ser necessárias bibliotecas adicionais como asyncio, que ajuda a organizar e coordenar a execução de operações assíncronas.

Procuramos todos os cartões de produtos, percorremos cada cartão e extraímos o link do produto:

        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 'Sem nome'

Link para a página do produto:

 product_link = title_tag.get_attribute('href') if title_tag else 'Sem link'

Se o link for relativo, adicionamos o URL base:

  if product_link and not product_link.startswith('http'):
             product_link = f'https://parsemachine.com{product_link}'

Fechamos o navegador e chamamos a função de execução:

        browser.close()
    scrape_with_playwright()

Código completo:

from playwright.sync_api import sync_playwright

# URL da página alvo
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) # Mude para True se quiser modo headless
        # Abrir nova aba
        page = browser.new_page()
        
        # Acessar a página alvo
        page.goto(url)
        
        # Buscar todos os cartões de produtos
        product_cards = page.query_selector_all('.card.product-card')
        
        for card in product_cards:
            # Extrair o link do produto
            title_tag = card.query_selector('.card-title .title')
            title = title_tag.inner_text() if title_tag else 'Sem nome'
            
            # Link do produto
            product_link = title_tag.get_attribute('href') if title_tag else 'Sem link'
            
            # Se o link for relativo, adiciona o URL base
            if product_link and not product_link.startswith('http'):
                product_link = f'https://parsemachine.com{product_link}'
            
            # Exibir informação do produto
            print(f'Nome: {title}, Link: {product_link}')
        
        browser.close()
scrape_with_playwright()

Ao executar o script, ele exibirá todas as informações necessárias com os nomes de cada produto e seus links:

Como salvar as informações extraídas?

Para salvar as informações extraídas, é necessário conhecer um pouco sobre os formatos de armazenamento de resultados:

CSV – um dos formatos mais populares para armazenar dados tabulares. Ele é um arquivo de texto em que cada linha corresponde a um registro e os valores são separados por vírgulas. Vantagens: suportado pela maioria dos programas de análise de dados, incluindo Excel, fácil de ler e editar em editores de texto. Desvantagens: capacidades limitadas para armazenar estruturas complexas de dados (por exemplo, dados aninhados). Problemas com escape de vírgulas e caracteres especiais.

JSON – é um formato de troca de dados em texto, útil para representar dados estruturados. É amplamente usado no desenvolvimento web. Vantagens: suporta estruturas aninhadas e hierárquicas; amplamente suportado por várias linguagens de programação; fácil de ler tanto por humanos quanto por máquinas. JSON é adequado para dados que podem ser transmitidos via API. Desvantagens: JSON pode gerar arquivos maiores que CSV; é mais lento para processar devido à estrutura mais complexa.

XLS – destinado a tabelas do Excel, onde são armazenados dados de células, formatação e fórmulas. É frequentemente usado para armazenar bancos de dados. Para trabalhar com XLS em Python, são necessárias bibliotecas externas, como pandas. Esse formato permite armazenar dados de forma legível e apresentável. A principal desvantagem é a necessidade de bibliotecas adicionais, o que aumenta a carga no servidor e o tempo de processamento dos dados.

XML – é uma linguagem de marcação usada para armazenar e transmitir dados. Suporta estruturas aninhadas e atributos. Vantagens: estruturado, permite armazenar dados complexos, bem suportado por diversos padrões e sistemas. Desvantagens: XML pode ser pesado e complexo de processar; a análise pode ser lenta devido à sua estrutura.

Bancos de dados são usados para armazenar grandes volumes de dados estruturados. Exemplos incluem MySQL, PostgreSQL, MongoDB, SQLite. Vantagens: suporte a grandes volumes de dados e acesso rápido; facilidade para organizar e relacionar dados; suporte a transações e recuperação de dados. Desvantagem: exige esforço adicional de configuração e manutenção.

Para nossos scrapers, escolheremos o formato CSV, porque os dados extraídos são tabulares (texto da citação e autor, nomes de produtos e seus links) e o volume de dados é relativamente pequeno, sem estruturas aninhadas. Mais informações sobre como ler e escrever nesse formato podem ser encontradas aqui. Vamos adicionar ao nosso código de citações a importação do CSV, criar um objeto writer e gravar os dados das citações (texto e autores):

    with open('quotes.csv', 'w', newline='', encoding='utf-8') as csvfile:
        csvwriter = csv.writer(csvfile)

        csvwriter.writerow(['Citação', 'Autor'])

        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])

Também adicionaremos saídas no console e tratamento de possíveis erros:

    print("Dados gravados com sucesso em quotes.csv")

except requests.RequestException as e:
    print(f'Erro ao requisitar a página: {e}')
except Exception as e:
    print(f'Ocorreu um erro: {e}')

Código completo:

import requests
from bs4 import BeautifulSoup
import csv

url = 'https://quotes.toscrape.com/'
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36'
}

try:
    response = requests.get(url, headers=headers)
    response.raise_for_status()

    soup = BeautifulSoup(response.text, 'html.parser')

    quotes = soup.select('.quote')

    with open('quotes.csv', 'w', newline='', encoding='utf-8') as csvfile:
        csvwriter = csv.writer(csvfile)

        csvwriter.writerow(['Citação', 'Autor'])

        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])

    print("Dados gravados com sucesso em quotes.csv")

except requests.RequestException as e:
    print(f'Erro ao requisitar a página: {e}')
except Exception as e:
    print(f'Ocorreu um erro: {e}')

Faremos o mesmo com o segundo scraper:

from playwright.sync_api import sync_playwright
import csv

url = 'https://parsemachine.com/sandbox/catalog/'

def scrape_with_playwright():
    try:
        with sync_playwright() as p:
            browser = p.chromium.launch(headless=False)

            try:
                page = browser.new_page()

                page.goto(url)

                product_cards = page.query_selector_all('.card.product-card')

                with open('products.csv', 'w', newline='', encoding='utf-8') as csvfile:
                    csvwriter = csv.writer(csvfile)

                    csvwriter.writerow(['Nome', 'Link'])

                    for card in product_cards:
                        title_tag = card.query_selector('.card-title .title')
                        title = title_tag.inner_text() if title_tag else 'Sem nome'

                        product_link = title_tag.get_attribute('href') if title_tag else 'Sem link'

                        if product_link and not product_link.startswith('http'):
                            product_link = f'https://parsemachine.com{product_link}'

                        csvwriter.writerow([title, product_link])

                        print(f'Nome: {title}, Link: {product_link}')

                print("Dados gravados com sucesso em products.csv")

            except Exception as e:
                print(f'Erro ao trabalhar com Playwright: {e}')

            finally:
                browser.close()
                print("Navegador fechado.")

    except Exception as e:
        print(f'Erro ao iniciar Playwright: {e}')

scrape_with_playwright()

Recomendações para um scraping bem-sucedido

Use rotação de proxies e User-Agent para evitar bloqueios de IP e contornar limitações de requisições, isso ajuda a simular acessos de diferentes dispositivos e navegadores.
Adicione tratamento de erros e tentativas automáticas: uma página pode ficar temporariamente indisponível ou uma requisição pode falhar. Um mecanismo de retry e tratamento de erros ajuda a manter a estabilidade do script e evita interrupções no processo de scraping.
Antes de iniciar o scraping, sempre consulte o arquivo robots.txt do site. Esse arquivo contém recomendações para bots sobre quais partes do site podem ou não ser rastreadas. Seguir essas regras ajuda a evitar problemas legais e conflitos com os proprietários dos sites.
Adicione atrasos aleatórios entre requisições para evitar atividades suspeitas e reduzir a chance de bloqueio.

Essas recomendações ajudam seu script a simular o comportamento de um usuário real, reduzindo assim a probabilidade de detecção.

Conclusão

Assim, o web scraping em Python é uma das formas mais populares de coleta eficiente de dados de diferentes sites. Discutimos como escolher ferramentas adequadas para scraping, analisamos o processo de instalação do Python e das bibliotecas necessárias, além da escrita de código para extração de dados e salvamento dos resultados em formatos convenientes. Com uma abordagem passo a passo, qualquer desenvolvedor iniciante pode aprender as técnicas básicas de web scraping e criar seus primeiros scripts de coleta de dados. O web scraping abre grandes possibilidades para análise de dados, coleta de informações, monitoramento de mercado e muitas outras tarefas. É importante continuar estudando novas ferramentas e metodologias para se manter atualizado nessa área em constante evolução.

Usando bibliotecas e ferramentas como BeautifulSoup, requests, Selenium, Playwright e outras mencionadas neste guia, é possível extrair informações tanto de sites estáticos quanto dinâmicos. Ao trabalhar com web scraping, é importante considerar aspectos legais e éticos, além de estar preparado para lidar com obstáculos como CAPTCHA ou carregamento dinâmico de conteúdo.

Cada uma das ferramentas e abordagens apresentadas possui suas próprias vantagens e limitações. A escolha da ferramenta adequada depende da especificidade da tarefa, da complexidade das páginas web e do volume de dados. Para um scraping eficiente, é essencial entender as características das páginas com as quais você está trabalhando.

Esperamos que as instruções acima ajudem você a entender melhor o processo de web scraping e forneçam os conhecimentos básicos necessários para criar seus próprios scrapers. Boa sorte nos seus projetos de automação de coleta e análise de dados!

NB: Por favor, observe que o produto é destinado exclusivamente à automação de testes em seus próprios sites e recursos aos quais você possui direito legal de acesso.