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:
| Recurso | Sucata | Pyspider |
|---|---|---|
| Caso de uso | Projetos de raspagem complexos e em grande escala | Tarefas de raspagem programadas |
| Gerenciamento de raspagem | CLI | CLI e UI |
| Métodos de análise | Seletores XPath e CSS | Seletores CSS |
| Economia de dados | Pode exportar dados para CSVs e outros formatos de arquivo | Salva automaticamente os dados no banco de dados |
| Repetir | Necessita de intervenção manual para tentar novamente | Tentativas automáticas de tarefas com falha |
| Programação de tarefas | Necessita de integrações externas | Com suporte nativo |
| Rotação de proxy | Oferece suporte à rotação de proxy por meio de middlewares | Requer intervenção manual |
| Comunidade | Comunidade Hige, atualmente com mais de 54 mil estrelas no GitHub, que contribui ativamente para ela | Vasta comunidade, atualmente com mais de 16 mil estrelas no GitHub, mas arquivada desde 11 de junho de 2024 |
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.pyque 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étodogetResourceInst()paraget_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étodorow.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 72 milhões 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!
