Scrapy vs Pyspider: Qual é o melhor para raspagem da Web?

Neste guia Scrapy vs Pyspider, você aprenderá:

• O que são Scrapy e Pyspider
• Uma comparação entre o Scrapy e o Pyspider para raspagem da Web
• Como usar o Scrapy e o Pyspider para raspagem da Web
• Limitações comuns entre o Scrapy e o Pyspider em cenários de raspagem da Web

Vamos mergulhar de cabeça!

O que é o Scrapy?

O Scrapy é uma estrutura de raspagem da Web de código aberto escrita em Python. Seu principal objetivo é extrair dados de sites de forma rápida e eficiente. Em detalhes, ele permite que você:

• Definir como navegar e coletar informações de uma ou mais páginas da Web.
• Lidar com aspectos como solicitações HTTP, acompanhamento de links e extração de dados.
• Evite o banimento ajustando a velocidade da solicitação com limitação e solicitações assíncronas.
• Gerencie proxies e rotação de proxies por meio de middleware personalizado ou da biblioteca scrapy-rotating-proxies.

O que é o Pyspider?

O Pyspider é uma estrutura de rastreamento da Web de código aberto escrita em Python. Ele foi desenvolvido para extrair dados de sites com facilidade e flexibilidade e permite que você:

• Definir como navegar e coletar informações de uma ou mais páginas da Web por meio da CLI ou de uma interface da Web amigável.
• Lidar com aspectos como agendamento de tarefas, novas tentativas e armazenamento de dados.
• Limite os bloqueios com suporte a rastreamento distribuído e tarefas priorizadas.
• Gerencie fluxos de trabalho e processamento de dados complexos com suporte integrado a bancos de dados e filas de mensagens.

Scrapy vs Pyspider: Comparação de recursos para Web Scraping

Agora que você já sabe o que são o Scrapy e o Pyspider, é hora de compará-los para a raspagem da Web:

A tabela de comparação entre Scrapy e Pyspider acima mostra que essas duas bibliotecas são semelhantes. As principais diferenças em um alto nível são:

• O Scrapy só pode ser usado por meio da CLI, enquanto o Pyspider também fornece uma interface do usuário.
• O Scrapy pode analisar seletores XPath e CSS, enquanto o Pyspider suporta apenas seletores CSS.
• O Scrapy suporta automaticamente a rotação de proxy por meio de lógica de middleware personalizada.

No entanto, o que é realmente importante considerar é que o Pyspider não é mais suportado:

Scrapy vs Pyspider: Comparação de raspagem direta

Depois de comparar o Scrapy com o Pyspider, você aprendeu que essas duas estruturas oferecem recursos de raspagem da Web semelhantes. Por esse motivo, a melhor maneira de compará-los é por meio de um exemplo real de codificação.

As próximas duas seções mostrarão como usar o Scrapy e o Pyspider para extrair o mesmo site. Em detalhes, a página de destino será a página “Hokey Teams” do Scrape This Site. Ela contém dados de hóquei em um formato tabular:

O objetivo dessas seções é recuperar todos os dados da tabela e salvá-los localmente. Vamos ver como!

Como usar o Scrapy para raspagem da Web

Neste parágrafo, você aprenderá a usar o Scrapy para recuperar todos os dados da tabela fornecida pelo site de destino.

Requisitos

Para seguir este tutorial, você deve ter o Python 3.7 ou superior instalado em sua máquina.

Etapa 1: Configuração do ambiente e instalação de dependências

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

hockey_scraper/
   └── venv/

Você pode criar o diretório do ambiente virtual venv/ da seguinte forma:

python -m venv venv

Para ativá-lo, no Windows, execute:

venvScriptsactivate

De forma equivalente, no macOS/Linux, execute:

source venv/bin/activate

Agora você pode instalar o Scrapy com:

pip install scrapy

Etapa 2: iniciar um novo projeto

Agora você pode iniciar um novo projeto Scrapy. Dentro da pasta hockey_scraper/ main, digite:

scrapy startproject hockey

Com esse comando, o Scrapy criará uma pasta hockey/. Dentro dela, ele gerará automaticamente todos os arquivos de que você precisa. Esta é a estrutura de pastas resultante:

hockey_scraper/ 
    ├── hockey/ # Main Scrapy project folder
    │   ├── __init__.py  
    │   ├── items.py # Defines the data structure for scraped items 
    │   ├── middlewares.py # Custom middlewares
    │   ├── pipelines.py # Handles post-processing of scraped data 
    │   ├── settings.py # Project settings 
    │   └── spiders/ # Folder for all spiders  
    ├── venv/ 
    └── scrapy.cfg # Scrapy configuration file

Etapa nº 3: Gerar a aranha

Para gerar um novo spider para rastrear o site de destino, primeiro vá para a pasta hockey/:

cd hockey

Em seguida, gere uma nova aranha com:

scrapy genspider data https://www.scrapethissite.com/pages/forms/

Nesse script, data representa o nome da aranha. O Scrapy criará automaticamente um arquivo data.py dentro da pasta spiders/. Esse arquivo conterá a lógica de raspagem necessária para recuperar os dados da equipe Hokey.

Etapa 4: Definir a lógica de raspagem

Você está pronto para codificar a lógica de raspagem. Primeiro, inspecione a tabela que contém os dados de interesse em seu navegador. Você pode ver que os dados estão contidos em um elemento .table:

Para obter todos os dados, escreva o seguinte código no arquivo data.py:

import scrapy

class DataSpider(scrapy.Spider):
    name = "data"
    allowed_domains = ["www.scrapethissite.com"]
    start_urls = ["https://www.scrapethissite.com/pages/forms/"]
    
    def parse(self, response):
        for row in response.css("table.table tr"):
            yield {
                "name": row.css("td.name::text").get(),
                "year": row.css("td.year::text").get(),
                "wins": row.css("td.wins::text").get(),
                "losses": row.css("td.losses::text").get(),
                "ot_losses": row.css("td.ot-losses::text").get(),
                "pct": row.css("td.pct::text").get(),
                "gf": row.css("td.gf::text").get(),
                "ga": row.css("td.ga::text").get(),
                "diff": row.css("td.diff::text").get(),
            }

Observe que as variáveis name, allowed_domains e start_urls foram criadas automaticamente pelo Scrapy na etapa anterior.

Até mesmo o método parse() foi criado automaticamente pelo Scrapy. Portanto, você só precisa adicionar a lógica de raspagem nesta etapa, que está sob o loop for.

Em detalhes, o método response.css() procura a tabela. Em seguida, o código itera sobre todas as linhas da tabela e obtém os dados.

Etapa 5: Execute o rastreador e salve os dados em um arquivo CSV

Para executar o rastreador e salvar os dados extraídos em um arquivo CSV, digite o seguinte:

scrapy crawl data -o output.csv

Com esse código, o Scrapy:

• Executa o arquivo data.py que contém a lógica de raspagem
• Salva os dados extraídos em um arquivo CSV chamado output.csv

O arquivo output.csv esperado produzido pelo scraper é:

Observe que essa maneira de usar o Scrapy é a mais curta, mas não é a única. O Scrapy oferece diferentes personalizações e configurações, e você pode saber mais sobre isso em nosso artigo sobre Scrapy vs Requests.

Como usar o Pyspider para raspagem da Web

Veja como usar o Pyspider para extrair o mesmo site de destino.

Requisitos

O Pyspider suporta Python3.6 como a versão mais recente. Se você tiver versões posteriores do Python instaladas, leia a etapa a seguir para saber como usar a versão 3.6.

Etapa 1: Configuração do ambiente e instalação de dependências

Suponha que você chame a pasta principal de seu projeto de hockey_scraper/.

Se você tiver o Python 3.7 ou posterior, instale o pyenv para obter o Python 3.6.

Use o pyenv para instalar o Python 3.6 com este comando:

pyenv install 3.6.15

Em seguida, torne-a a versão local do Python, para que você não afete todo o sistema com uma versão diferente:

pyenv local 3.6.15

Para ter certeza de que tudo correu bem, verifique a versão do Python:

python --version

O resultado deve ser:

Python 3.6.15

Crie um ambiente virtual selecionando a versão correta do Python:

python3.6 -m venv venv

Ative o ambiente virtual conforme mostrado no capítulo anterior deste guia. Agora, você pode instalar o Pyspider com:

pip install pyspider

Para iniciar a execução da interface do usuário:

pyspider

Observe que, como esse repositório está arquivado e você está usando o Python 3.6, receberá alguns erros. Para corrigi-los, talvez seja necessário instalar as seguintes bibliotecas:

pip install tornado==4.5.3 requests==2.25.1

Você também pode receber outros erros relacionados ao arquivo webdav.py. Procure o arquivo e corrija o seguinte:

• Na classe ScriptProvider(), renomeie o método getResourceInst() para get_resource_inst()
• Na parte inferior do arquivo, procure a variável config = DEFAULT_CONFIG.copy() e altere todo o código subsequente para:

config = DEFAULT_CONFIG.copy()
config.update({
    "mount_path": "/dav",
    "provider_mapping": {
        "/": ScriptProvider(app)
    },
    "domaincontroller": NeedAuthController(app),
    "verbose": 1 if app.debug else 0,
    "dir_browser": {"davmount": False,
                    "enable": True,
                    "msmount": False,
                    "response_trailer": ""},
})
dav_app = WsgiDAVApp(config)

Agora, a interface do usuário da Web do pyspider deve poder ser iniciada. Acesse http://localhost:5000/ em seu navegador e você verá o seguinte:

Etapa 2: Criar um novo projeto

Clique em “Create” (Criar) para criar um novo projeto e preencha os campos:

• Escolha um nome de projeto de sua preferência, por exemplo, Hockey_scraper.
• Defina https://www.scrapethissite.com/pages/forms/ no campo URL(s) inicial(is).

Esse deve ser o resultado:

Etapa nº 3: Definir a lógica de raspagem

Implemente a lógica de raspagem escrevendo o código Python diretamente no editor, na parte direita da interface do usuário:

from pyspider.libs.base_handler import *

class Handler(BaseHandler):
    crawl_config = {}

    @every(minutes=24 * 60)
    def on_start(self):
        self.crawl("https://www.scrapethissite.com/pages/forms/", callback=self.index_page)

    @config(age=10 * 24 * 60 * 60)
    def index_page(self, response):
        for each in response.doc("table.table tr").items():
            self.crawl(each.attr.href, callback=self.detail_page)

    @config(priority=2)
    def detail_page(self, response):
        return {
            "name": row.css("td.name::text").get(),
            "year": row.css("td.year::text").get(),
            "wins": row.css("td.wins::text").get(),
            "losses": row.css("td.losses::text").get(),
            "ot_losses": row.css("td.ot-losses::text").get(),
            "pct": row.css("td.pct::text").get(),
            "gf": row.css("td.gf::text").get(),
            "ga": row.css("td.ga::text").get(),
            "diff": row.css("td.diff::text").get(),
        }

Aqui está o que mudou em relação ao código padrão:

• O método response.doc() procura a tabela de destino.
• detail_page() retorna as linhas que são interceptadas por meio do método row.css().

Clique em “Save” (Salvar) e “Run” (Executar) para iniciar o processo de raspagem. Os dados resultantes serão semelhantes aos que você obteve com o Scrapy.

Muito bom! Agora você sabe como usar o Scrapy e o Pyspider para raspagem da Web.

Scrapy vs Pyspider: Qual deles usar?

A comparação entre o Scrapy e o Pyspider mostrou como usá-los, mas qual deles é melhor? É hora de descobrir!

Escolha Scrapy:

• Para projetos de alto desempenho que precisam de rastreamento paralelo e recursos avançados, como limitação.
• Se você precisar integrar sua raspagem com pipelines externos ou outras ferramentas.
• Se você tiver confiança no uso da CLI e em cenários de raspagem da Web e preferir uma estrutura atualizada.

Escolha o Pyspider se:

• Você prefere usar uma interface de usuário em vez da CLI.
• Você deseja trabalhar em um sistema distribuído e prefere configurações simples.
• Você deseja agendar tarefas de raspagem.

Como sempre, não há um vencedor definitivo – a melhor ferramenta de raspagem depende inteiramente de suas necessidades específicas e do caso de uso.

Limitações do Scrapy e do Pyspider

O Scrapy e o Pyspider são estruturas poderosas para raspagem da Web, mas têm suas limitações.

Em primeiro lugar, eles têm dificuldade em extrair sites de conteúdo dinâmico que usam JavaScript para renderização ou recuperação de dados. Embora ambos possam ser estendidos para fazer a coleta de dados de sites com JavaScript, eles são inerentemente limitados nesse aspecto. Isso também os torna mais suscetíveis a medidas comuns de antirrastreamento.

Além disso, essas duas estruturas estão sujeitas a proibições de IP, pois fazem muitas solicitações automatizadas. Elas podem acionar limitadores de taxa, o que faz com que seu IP seja colocado na lista negra. Uma solução para evitar que seu IP seja banido é integrar proxies em seu código.

Para rotação de proxy, consulte nosso guia sobre como usar proxies para rotacionar endereços IP em Python.

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

• Proxies de data center: Mais de 770.000 IPs de data center.
• Proxies residenciais: Mais de 150 million+ de IPs residenciais em mais de 195 países.
• Proxies de ISP: Mais de 700.000 IPs de ISPs.
• Proxies móveis: Mais de 7 milhões de IPs móveis.

Conclusão

Nesta postagem do blog Scrapy vs Pyspider, você aprendeu sobre a função das duas bibliotecas na raspagem da Web. Você explorou seus recursos para extração de dados e comparou seu desempenho em um cenário real de paginação.

O Pyspider oferece uma interface de usuário amigável, mas, infelizmente, está obsoleto. O Scrapy, em vez disso, é útil para grandes projetos, pois fornece a maioria das ferramentas necessárias para a raspagem estruturada e sua tecnologia subjacente está atualizada com as versões mais recentes do Python.

Você também descobriu suas limitações, como possíveis proibições de IP. Felizmente, esses desafios podem ser superados usando proxies ou soluções dedicadas de raspagem da Web, como a API Web Scraper da Bright Data. Essa API focada em raspagem se integra perfeitamente ao Scrapy, ao Pyspider e a qualquer outro cliente HTTP ou ferramenta de raspagem da Web, permitindo a extração irrestrita de dados.

Crie uma conta gratuita na Bright Data hoje mesmo para explorar nossas APIs de proxy e scraper!