Scrapy vs. Requests: qual é o melhor para Scraping de dados?

Neste guia Scrapy vs Requests, você verá:

• O que são Scrapy e Requests
• Uma comparação entre Scrapy e Requests para Scraping de dados
• Uma comparação entre Scrapy e Requests em um cenário de paginação
• Limitações comuns entre o Scrapy e o Requests em cenários de Scraping de dados

Vamos começar!

O que é Requests?

Requestsé uma biblioteca Python para enviar solicitações HTTP. É amplamente utilizada no Scraping de dados, geralmente combinada com bibliotecas de Parsing de HTML, comoBeautifulSoup.

Os principais recursos do Requests para Scraping de dados incluem:

• Suporte para métodos HTTP: você pode usar todos os principais métodos HTTP, comoGET,POST,PUT,PATCH eDELETE, que são essenciais para interagir com páginas da web e APIs.
• Cabeçalhos personalizados: defina cabeçalhos personalizados (por exemplo,User-Agente outros) para imitar um navegador real ou lidar com autenticação básica.
• Gerenciamento de sessão: o objetorequests.Session()permite que você mantenha cookies e cabeçalhos em várias solicitações. Isso é útil para fazer scraping em sites que exigem login ou manutenção de estados de sessão.
• Tempos limite e tratamento de erros: você pode definir tempos limite para evitar solicitações pendentes e lidar com exceções para uma extração robusta.
• Suporte a Proxy: você pode encaminhar suas solicitações por meio de Proxies, o que é útil para contornar bloqueios de IP e acessar conteúdo com restrição geográfica.

O que é o Scrapy?

Scrapyé uma estrutura de Scraping de dados da web de código aberto escrita em Python. Ela foi criada para extrair dados de sites de maneira rápida, eficiente e escalável.

O Scrapy fornece uma estrutura completa para rastrear sites, extrair dados e armazená-los em vários formatos (por exemplo, JSON, CSV, etc.). É particularmente útil para projetos de Scraping de dados em grande escala, pois pode lidar com tarefas complexas de rastreamento e solicitações simultâneas, respeitando as regras de rastreamento.

Os principais recursos do Scrapy para Scraping de dados incluem:

• Rastreamento da web integrado: o Scrapy foi projetado para ser umrastreador da web. Isso significa que ele pode seguir links em uma página da web automaticamente, permitindo que você faça o scraping de várias páginas ou sites inteiros com o mínimo de esforço.
• Solicitações assíncronas: ele usa uma arquitetura assíncrona para lidar com várias solicitações simultaneamente. Isso o torna muito mais rápido do queclientes HTTP Python, comosolicitações.
• Seletores para extração de dados: o Scrapy oferece a possibilidade de extrair dados de HTML usando XPaths e seletores CSS.
• Middleware para personalização: ele suporta middleware para personalizar como as solicitações e respostas são tratadas.
• Limitação automática: ele pode limitar automaticamente as solicitações para evitar sobrecarregar o servidor de destino. Isso significa que ele pode ajustar a velocidade de rastreamento com base nos tempos de resposta e na carga do servidor.
• Tratamentodo robots.txt: respeita oarquivorobots.txtpara Scraping de dados, garantindo que suas atividades de scraping estejam em conformidade com as regras do site.
• Rotação de proxy e agente do usuário: o Scrapy suportarotação de proxyerotaçãode agente do usuáriopor meio de middlewares, o que ajuda a evitar banimentos e detecção de IP.

Scrapy vs Requests: comparação de recursos para Scraping de dados

Agora que você aprendeu o que são Requests e Scrapy, é hora de fazer uma comparação profunda de seus usos para Scraping de dados:

Casos de uso

O Scrapy é uma estrutura completa de Scraping de dados para projetos de scraping complexos e em grande escala. É ideal para tarefas que envolvem rastreamento de várias páginas, solicitações simultâneas e exportação de dados em formatos estruturados.

Por outro lado, o Requests é uma biblioteca que gerencia solicitações HHTP. Portanto, é mais adequado para tarefas simples, como buscar uma única página da web, interagir com APIs ou baixar arquivos.

Solicitações assíncronas e simultaneidade

O Scrapy é baseado noTwisted, uma estrutura de rede orientada a eventos para Python. Isso significa que ele pode lidar com solicitações assíncronas e múltiplas simultaneamente, tornando-o muito mais rápido para scraping em grande escala.

O Requests, por outro lado, não oferece suporte nativo a solicitações assíncronas ou simultâneas. Se você deseja fazer solicitações HTTP assíncronas, pode integrá-lo aoGRequests.

Rastreamento

Quando a configuraçãoROBOTSTXT_OBEYé definida comoTrue, o Scrapy lê o arquivorobots.txt, seguindo automaticamente os links permitidos em uma página da web e rastreando as páginas permitidas.

O Requests não possui recursos de rastreamento integrados, portanto, você precisa definir manualmente os links e fazer solicitações adicionais.

Extração de dados

O Scrapy oferece suporte integrado para extração de dados usandoseletores XPath e CSS, facilitando o Parsing de HTML e XML.

O Requests não inclui nenhum recurso de extração de dados. Você precisa usar bibliotecas externas, comoBeautifulSoup, para realizar Parsing e extrair dados.

Middleware

O Scrapy oferece middlewares personalizáveis para lidar comProxies,novas tentativas,cabeçalhos e muito mais. Isso o torna altamente extensível para tarefas avançadas de raspagem.

Por outro lado, o Requests não oferece suporte a middleware, então você precisa implementar manualmente recursos comorotação de Proxyou repetições.

Limitação

O Scrapy inclui um recurso integrado de limitação automática usado para ajustar a velocidade de rastreamento com base nos tempos de resposta e na carga do servidor. Dessa forma, você pode evitar sobrecarregar o servidor de destino com solicitações HTTP.

O Requests não possui um recurso de throttling integrado. Se você deseja implementar o throttling, precisa adicionar manualmente atrasos entre as solicitações, por exemplo, usando o método time.sleep().

Rotação de proxy

O Scrapy oferece suporte à rotação de Proxy por meio de middlewares, facilitando evitar bloqueios de IP e rastrear sites anonimamente.

O Requests não oferece um recurso integrado de rotação de Proxy. Se você deseja gerenciar proxies como Requests, é necessário configurar manualmente os proxies e escrever uma lógica personalizada,conforme explicado em nosso guia.

Tratamento de erros

O Scrapy inclui mecanismos de repetição integrados parasolicitações com falha, tornando-o robusto para lidar com erros de rede ou problemas de servidor.

Por outro lado, o Requests exige que você trate manualmente os erros e exceções, por exemplo, usando o blocotry-except. Considere também bibliotecas comoretry-requests.

Downloads de arquivos

O Scrapy oferece suporte a downloads de arquivos por meio doFilesPipeline, mas requer configuração adicional para lidar com arquivos grandes ou streaming.

O Requests oferece suporte simples e direto para download de arquivos com o parâmetro stream=True no método requests.get().

Scrapy vs Requests: comparando as duas bibliotecas em um cenário de paginação

Agora você sabe o que são Requests e Scrapy. Prepare-se para ver um tutorial passo a passo comparando os dois em um cenário específico de Scraping de dados!

O foco será mostrar uma comparação entre essas duas bibliotecas em um cenário de paginação.Lidar com paginação no Scraping de dadosrequer lógica personalizada para seguir links e extrair dados em várias páginas.

O site de destino seráo Quotes to Scrape, que fornece citações de autores famosos em diferentes páginas:

O objetivo do tutorial é mostrar como usar o Scrapy e o Requests para recuperar as citações de todas as páginas. Começaremos com o Requests, pois ele pode ser mais complexo de usar do que o Scrapy.

Requisitos

Para replicar os tutoriais do Scrapy e do Requests, você deve tero Python 3.7 ou superiorinstalado em sua máquina.

Como usar o Requests para Scraping de dados

Neste capítulo, você aprenderá como usar o Requests para extrair todas as citações do site de destino.

Lembre-se de que você não pode usar o Requests sozinho para extrair dados diretamente de páginas da web. Você também precisará de umanalisador HTML como o BeautifulSoup.

Etapa 1: Configurando o ambiente e instalando dependências

Suponha que você chame a pasta principal do seu projeto de requests_scraper/. Ao final desta etapa, a pasta terá a seguinte estrutura:

requests_scraper/
    ├── requests_scraper.py
    └── venv/

Onde:

• requests_scraper.pyé o arquivo Python que contém todo o código
• venv/contém o ambiente virtual

Você pode criar o diretóriodo ambiente virtualvenv/da seguinte maneira:

python -m venv venv

Para ativá-lo, no Windows, execute:

venvScriptsactivate

Da mesma forma, no macOS e no Linux, execute:

source venv/bin/activate

Agora você pode instalar as bibliotecas necessárias com:

pip install requests beautifulsoup4

Etapa 2: Configurando as variáveis

Agora você está pronto para começar a escrever código no arquivo requests_scraper.py.

Primeiro, configure as variáveis da seguinte forma:

base_url = "https://quotes.toscrape.com"
all_quotes = []

Aqui você definiu:

• base_urlcomo a URL inicial do site a ser rastreado
• all_quotescomo uma lista vazia usada para armazenar todas as cotações à medida que são coletadas

Etapa 3: Crie a lógica de extração

Você pode implementar a lógica de extração e rastreamento com o seguinte código:

url = base_url
while url:
    # Envie uma solicitação GET para a página atual
    response = requests.get(url)

    # Analise o código HTML da página
    soup = BeautifulSoup(response.text, "html.parser")

    # Encontre todos os blocos de citações
    quotes = soup.select(".quote")
    for quote in quotes:
        text = quote.select_one(".text").get_text(strip=True)
        author = quote.select_one(".author").get_text(strip=True)
        tags = [tag.get_text(strip=True) para tag em citação.select(".tag")]
        todas_as_citações.append({
            "texto": texto, 
            "autor": autor, 
            "tags": ",".join(tags)
        })

    # Verificar se existe o botão "Próximo"
    botão_próximo = soup.select_one("li.next")
    se botão_próximo:
        # Extraia a URL do botão “Próximo” e
        # defina-a como a próxima página a ser extraída
        próxima_página = botão_próximo.select_one("a")["href"]
        url = url_base + próxima_página
    caso contrário:
        url = Nenhum

Este código:

• Instancia um loopwhileque continuará a ser executado até que todas as páginas sejam extraídas
• Sob o loopwhile:
  • soup.``select``()intercepta todos os elementos HTML de citação na página. O HTML da página é estruturado de forma que cada elemento de citação tenha uma classe chamadaquote.
  • O cicloforitera todas as classesde citaçãopara extrair o texto, o autor e as tags das citações com os métodos de extração do Beautiful Soup. Aqui, você precisa de uma lógica personalizada para tags, pois cada elemento de citação pode conter mais de uma tag.
    
• Depois de extrair toda a página, o script procura o botãoseguinte. Se o botão existir, ele extrai o link para a próxima página. Em seguida, a URL base é atualizada para ser a próxima através da variávelurl = base_url + next_page. Quando o processo chega à última página, a próxima URL é definida comoNone e o processo termina.

Etapa 4: anexar os dados a um arquivo CSV

Agora que você coletou todos os dados, pode anexá-los a um arquivo CSV conforme abaixo:

com open("quotes.csv", mode="w", newline="", encoding="utf-8") como arquivo:
    writer = csv.DictWriter(arquivo, fieldnames=["texto", "autor", "tags"])
    writer.writeheader()
    writer.writerows(all_quotes)

Esta parte do script usa a bibliotecacsvpara:

• Especificar o nome do arquivo CSV de saída comoquotes.csv.
• Abrir o CSV no modo de escrita (mode="w") e:
  • Gravar a linha do cabeçalho no CSV
  • Gravar todas as citações coletadas no arquivo

Etapa 5: Junte tudo

Este é o código completo para esta parte do tutorial sobre Scrapy vs Requests:

import requests
from bs4 import BeautifulSoup
import csv

# URL do site
base_url = "https://quotes.toscrape.com"
# Lista para armazenar todas as citações
all_quotes = []

# Comece a coletar a partir da primeira página
url = base_url
while url:
    # Envie uma solicitação GET para a página atual
    response = requests.get(url)

    # Analise o código HTML da página
    soup = BeautifulSoup(response.text, "html.parser")

    # Encontrar todos os blocos de citações
    quotes = soup.select(".quote")
    para citação em citações:
        texto = citação.select_one(".text").get_text(strip=True)
        autor = citação.select_one(".author").get_text(strip=True)
        tags = [tag.get_text(strip=True) para tag em citação.select(".tag")]
        todas_as_citações.append({
            "texto": texto, 
            "autor": autor, 
            "tags": ",".join(tags)
        })

    # Verificar se existe o botão "Próximo"
    next_button = soup.select_one("li.next")
    if next_button:
        # Extraia a URL do botão “Próximo” e
        # defina-a como a próxima página a ser extraída
        next_page = next_button.select_one("a")["href"]
        url = base_url + next_page
    else:
        url = None

# Salvar as citações em um arquivo CSV
com open("quotes.csv", mode="w", newline="", encoding="utf-8") como arquivo:
    writer = csv.DictWriter(arquivo, fieldnames=["texto", "autor", "tags"])
    writer.writeheader()
    writer.writerows(all_quotes)

Execute o script acima:

python requests_scraper.py

Um arquivoquotes.csvaparecerá na pasta do projeto:

Como usar o Scrapy para Scraping de dados

Agora que você aprendeu a usar o Requests para Scraping de dados, está pronto para ver como usar o Scrapy com a mesma página de destino e objetivo.

Etapa 1: Configurando o ambiente e instalando dependências

Suponha que você queira chamar a pasta principal do seu projeto de scrapy_scraper/.

Primeiro, crie e ative um ambiente virtual como mostrado anteriormente e instale o Scrapy:

pip install scrapy

Inicie o Scrapy para preencher a pasta principal com arquivos predefinidos dentro de quotes_scraper/ com:

scrapy startproject quotes_scraper

Esta é a estrutura resultante do seu projeto:

scrapy_scraper/ 
├── quotes_scraper/ # Pasta principal do projeto Scrapy
│   ├── __init__.py  
│   ├── items.py # Define a estrutura de dados para itens coletados 
│   ├── middlewares.py # Middlewares personalizados
├── pipelines.py # Lida com o pós-processamento dos dados coletados
├── settings.py # Configurações do projeto
└── spiders/ # Pasta para todos os spiders
├── venv/
└── scrapy.cfg # Arquivo de configuração do Scrapy

Etapa #2: Defina os itens

O arquivo items.py define a estrutura dos dados que você deseja coletar. Como você deseja recuperar as citações, autores e tags, defina-os da seguinte forma:

import scrapy

class QuotesScraperItem(scrapy.Item):
    quote = scrapy.Field()
    author = scrapy.Field()
    tags = scrapy.Field()

Etapa 3: definir o spider principal

Dentro da pasta spiders/, crie os seguintes arquivos Python:

• __init__.py, que marca o diretório como um pacote Python
• quotes_spider.py

O quotes_spider.py contém a lógica real de scraping:

import scrapy
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from ..items import QuotesScraperItem

class QuotesSpider(CrawlSpider):
    name = "quotes"
    allowed_domains = ["quotes.toscrape.com"]
    start_urls = ["https://quotes.toscrape.com/"]

    # Definir regras para seguir links de paginação
    rules = (
        Rule(LinkExtractor(restrict_css="li.next a"), callback="parse_item", follow=True),
    )

    def parse_item(self, response):
        # Extrair citações, autores e tags
        for quote in response.css("div.quote"):
            item = QuotesScraperItem()
            item["quote"] = quote.css("span.text::text").get()
            item["author"] = quote.css("small.author::text").get()
            item["tags"] = quote.css("div.tags a.tag::text").getall()
            yield item

O trecho acima define a classe QuotesSpider() que faz o seguinte:

• Define a URL a ser rastreada.
• Define a regra para paginação com a classeRule(), permitindo que o rastreador siga todas as páginas seguintes.
• Extrai a citação, o autor e a tag com o métodoparse_item().

Etapa 4: definir as configurações

Anexar os dados a um CSV requer algumas configurações especiais no Scrapy. Para fazer isso, abra o arquivo settings.py e adicione as seguintes variáveis ao arquivo:

FEED_FORMAT = "csv"  
FEED_URI = "quotes.csv" 

Veja o que essas configurações fazem:

• FEED_FORMATdefine o formato de saída do arquivo (que pode ser de diferentes tipos)
• FEED_URIdefine o nome do arquivo de saída

Etapa 5: Execute o Crawler

Os arquivos Python não mencionados nas etapas anteriores não são úteis para este tutorial, portanto, você pode deixá-los com os dados padrão.

Para iniciar o rastreador, acesse a pasta quotes_scraper/:

cd quotes_scraper

Em seguida, execute o rastreador:

scrapy crawl quotes

Este comando instancia a classe QuotesSpider() no arquivo quotes_spider.py, que é o que inicia o rastreador. O arquivo CSV final que você obtém é idêntico ao que você obteve com Requests e BeautifulSoup!

Portanto, este exemplo mostra:

• Como o Scrapy é mais adequado para projetos grandes devido à sua natureza.
• Como o gerenciamento da paginação é mais fácil com o Scrapy, pois você só precisa gerenciar uma regra em vez de escrever uma lógica personalizada, como no caso anterior.
• Como anexar dados a um arquivo CSV é mais simples com o Scrapy. Isso porque você só precisa adicionar duas configurações em vez de criar a lógica personalizada clássica que você criaria ao escrever um script Python que faz isso.

Limitações comuns entre o Scrapy e o Requests

Embora o Scrapy e o Requests sejam amplamente utilizados em projetos de Scraping de dados, eles apresentam algumas desvantagens.

Mais especificamente, uma das limitações comuns a todas as bibliotecas ou estruturas de scraping éo banimento de IP. Você aprendeu que o Scrapy oferece limitação, o que ajuda a ajustar a velocidade com que o servidor é solicitado. Ainda assim, isso muitas vezes não é suficiente para evitar que seu IP seja banido.

A solução para evitar que seu IP seja banido é implementar Proxies em seu código. Vamos ver como!

Usando Proxy com Requests

Se você quiser usar um único Proxy em Requests, use a seguinte lógica:

 Proxy = {
     "http": "<HTTP_PROXY_URL>",
     "https": "<HTTPS_PROXY_URL>"
 }
 response = requests.get(url, proxies=Proxy)

Para saber mais sobre proxies e Proxy rotativo em solicitações, leia estes guias em nosso blog:

• Guia para usar um Proxy com Python Requests
• Como usar proxies para rodar endereços IP no Python

Usando Proxy no Scrapy

Se você deseja implementar um único Proxy em seu código, adicione as seguintes configurações ao arquivo settings.py:

# Configurar um único Proxy
HTTP_PROXY = "<PROXY_URL>"

# Habilite o HttpProxyMiddleware e desabilite o UserAgentMiddleware padrão
DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 110,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
}

Essas configurações encaminharão todas as solicitações através do Proxy especificado. Saiba mais em nossoguia de integração de Proxy Scrapy.

Em vez disso, se você deseja implementar proxies rotativos, pode usar abibliotecascrapy-rotating-proxies. Da mesma forma, você pode usar um Proxy residencial com rotação automática.

Se você estiver procurando proxies confiáveis, lembre-se de que a rede de proxies da Bright Data tem a confiança de empresas da Fortune 500 e mais de 20.000 clientes em todo o mundo. Essa extensa rede inclui:

• Proxies residenciais: mais de 72 milhões de IPs residencialis em mais de 195 países.
• Proxies de datacenter: plus de 770.000 IPs de datacenter.
• Proxies ISP: mais de 700.000 IPs de ISP.
• Proxies móveis: mais de 7 milhões de IPs móveis.

Conclusão

Nesta postagem do blog Scrapy vs Requests, você aprendeu sobre o papel das duas bibliotecas no Scraping de dados. Você explorou seus recursos para recuperação de páginas e extração de dados e comparou seu desempenho em um cenário real de paginação.

O Requests requer mais lógica manual, mas oferece maior flexibilidade para casos de uso personalizados, enquanto o Scrapy é um pouco menos adaptável, mas fornece a maioria das ferramentas necessárias para o scraping estruturado.

Você também descobriu suas limitações, como possíveis bloqueios de IP e problemas com conteúdo restrito geograficamente. Felizmente, esses desafios podem ser superadosusando proxiesou soluções dedicadas de Scraping de dados, comoos Web Scrapers da Bright Data.

Os Scrapers se integram perfeitamente ao Scrapy e ao Requests, permitindo que você extraia dados públicos dos principais sites sem restrições.

Crie hoje mesmo uma conta gratuita na Bright Data para explorar nossas APIs de Proxy e Scraper e comece seu Teste grátis!