Scrapy vs Playwright: Uma comparação para raspagem da Web

Neste guia, você aprenderá:

• O que é o Scrapy
• O que é um dramaturgo
• Os recursos que eles oferecem para raspagem da Web e como eles se comparam
• Uma introdução à raspagem da Web com ambas as ferramentas
• Como criar um scraper com o Playwright
• Como criar um script de raspagem da Web com o Scrapy
• Qual ferramenta é melhor para raspagem da Web?
• Suas limitações comuns e como superá-las

Vamos mergulhar de cabeça!

O que é o Scrapy?

O Scrapy é uma estrutura de raspagem da Web de código aberto escrita em Python, desenvolvida para a extração eficiente de dados. Ele oferece suporte integrado a recursos como solicitações paralelas, acompanhamento de links e exportação de dados em formatos como JSON e CSV. Além disso, apresenta middleware, integração de proxy e novas tentativas automáticas de solicitação. O Scrapy opera de forma assíncrona e em páginas HTML estáticas.

O que é um dramaturgo?

O Playwright é uma estrutura de automação de código aberto para testes E2E e raspagem da Web no navegador. Ele é compatível com vários navegadores, como Chrome, Firefox e WebKit, cada um no modo headless e headless. Além disso, a API de automação do navegador está disponível em várias linguagens de programação, incluindo TypeScript/JavaScript, Python, Java e C#.

Scrapy vs. Playwright: recursos de comparação para raspagem da Web

Vamos comparar o Scrapy e o Playwright em cinco aspectos diferentes que contribuem para torná-los excelentes ferramentas de raspagem da Web.

Para ver outras postagens de blog sobre confrontos diretos, leia:

• Scrapy vs. Beautiful Soup
• Scrapy vs Pyspider: Qual é o melhor para raspagem da Web?
• Scrapy vs. Selenium para raspagem da Web
• Scrapy vs. Puppeteer para raspagem da Web
• Scrapy vs. Requests: Qual é o melhor para raspagem da Web?

Agora, comece a comparação entre o Scrapy e o Playwright!

Facilidade de instalação e configuração

O Scrapy oferece uma instalação direta com o mínimo de configuração necessária. Você pode criar rapidamente um projeto, definir spiders e exportar dados, graças à sua CLI integrada. Por outro lado, o Playwright requer mais configuração, pois envolve a instalação de dependências do navegador e a verificação da configuração adequada.

Curva de aprendizado

O Scrapy tem uma curva de aprendizado mais acentuada para iniciantes devido à sua estrutura modular, recursos extensos e configurações exclusivas. A compreensão de conceitos como spiders, middlewares e pipelines pode levar tempo. É muito mais fácil começar a usar o Playwright, pois sua API é familiar para quem tem algum conhecimento de automação de navegador.

Manuseio de conteúdo dinâmico

O Scrapy tem dificuldades com sites que usam JavaScript, pois só consegue lidar com documentos HTML estáticos. A manipulação de conteúdo dinâmico é possível, mas requer integração com o Splash ou ferramentas semelhantes. O Playwright é excelente para lidar com conteúdo dinâmico ou renderizado em JavaScript porque renderiza páginas nativamente no navegador. Isso significa que você pode usá-lo para extrair páginas que dependem de estruturas de cliente como React, Angular ou Vue.

Personalização e extensibilidade

O Scrapy oferece muitas opções de personalização por meio do suporte a middlewares, extensões e pipelines. Além disso, há vários plug-ins e complementos disponíveis. O Playwright, por outro lado, não é nativamente extensível. Felizmente, a comunidade resolveu essa limitação com o projeto Playwright Extra.

Outros recursos de raspagem

O Scrapy o equipa com funcionalidades incorporadas, como integração de proxy, novas tentativas automáticas e exportação de dados configurável. Ele também oferece métodos integrados para rotação de IP e outros cenários avançados. O Playwright é compatível com a integração de proxy e outros recursos importantes de raspagem. Portanto, para obter os mesmos resultados, é necessário mais esforço manual em comparação com o Scrapy.

Playwright vs Scrapy: Comparação de scripts de raspagem

Nas duas seções a seguir, você aprenderá a extrair o mesmo site usando o Playwright e o Scrapy. Começaremos com o Playwright, pois isso pode levar um pouco mais de tempo, já que ele não é especificamente otimizado para raspagem da Web como o Scrapy.

O site de destino será a sandbox de raspagem Books to Scrape:

O objetivo de ambos os raspadores é recuperar todos os livros do Fantasy do site, o que exige a manipulação da paginação.

O Scrapy tratará as páginas como estáticas e analisará seus documentos HTML diretamente. Em vez disso, o Playwright as renderizará em um navegador e interagirá com os elementos das páginas, simulando as ações do usuário.

O script do Scrapy será escrito em Python, enquanto o script do Playwright será em JavaScript – as duas linguagens suportadas principalmente por ambas as ferramentas. Ainda assim, você pode converter facilmente o script JavaScript do Playwright para Python usando a biblioteca playwright-python, que expõe a mesma API subjacente.

Em ambos os casos, no final do script, você terá um CSV contendo todos os detalhes do livro Fantasy do Books to Scrape.

Agora, vamos começar a comparação entre a raspagem do Playwright e a do Scrapy!

Como usar o Playwright para raspagem da Web

Siga as etapas abaixo para escrever um script simples de raspagem da Web em JavaScript usando o Playwright. Se você não estiver familiarizado com o processo, leia primeiro nosso guia sobre raspagem da Web do Playwright.

Etapa 1: Configuração do projeto

Antes de começar, verifique se você tem a versão mais recente do Node.js instalada localmente. Caso contrário, faça o download e siga o assistente de instalação.

Em seguida, crie uma pasta para seu raspador do Playwright e navegue até ela usando o terminal:

mkdir playwright-scraper
cd playwright-scraper

Dentro da pasta playwright-scraper, inicialize um projeto npm executando:

npm init -y

Agora, abra a pasta playwright-scraper em seu IDE JavaScript favorito. O IntelliJ IDEA ou o Visual Studio Code são ótimas opções. Dentro da pasta, crie um arquivo script.js, que logo conterá a lógica de raspagem:

Excelente! Agora você está totalmente preparado para a raspagem da Web no Node.js com o Playwright.

Etapa 2: Instalar e configurar o Playwright

Na pasta do projeto, execute o seguinte comando para instalar o Playwright:

npm install playwright

Em seguida, instale o navegador e quaisquer dependências adicionais executando:

npx playwright install

Agora, abra o script.js e adicione o seguinte código para importar o Playwright e iniciar uma instância do navegador Chromium:

const { chromium } = require("playwright");

(async () => {
  // initialize a Chromium browser
  const browser = await chromium.launch({
    headless: false, // comment out in production
  });

  // scraping logic goes here...

  // close the browser and release resources
  await browser.close();
})();

A opção headless: false inicia o navegador no modo headless. Isso permite que você veja o que o script está fazendo, o que é útil para depuração durante o desenvolvimento.

Etapa nº 3: Conecte-se à página de destino

Inicialize uma nova página no navegador e use a função goto() para navegar até a página de destino:

const page = await browser.newPage();
await page.goto("https://books.toscrape.com/catalogue/category/books/fantasy_19/index.html");

Se você executar o script no depurador com um ponto de interrupção antes da função close(), verá o navegador abrir e navegar até a página de destino:

Incrível! O Playwright está controlando o navegador como esperado.

Etapa 4: implementar a lógica de análise de dados

Antes de escrever a lógica de raspagem, você precisa entender a estrutura da página. Para isso, abra o site de destino em uma janela anônima em seu navegador. Em seguida, clique com o botão direito do mouse em um elemento do livro e selecione a opção “Inspecionar”.

É isso que você deve ver no DevTools:

Acima, você pode observar que cada elemento do livro pode ser selecionado usando o seletor CSS .product_pod.

Como a página contém vários livros, primeiro inicialize uma matriz para armazenar os dados extraídos:

books = []

Selecione todos eles e itere sobre eles como abaixo:

const bookElements = await page.locator(".product_pod").all();
for (const bookElement of bookElements) {
  // extract book details...
}

De cada elemento do livro, conforme mostrado na imagem acima, você pode extrair:

• O URL do livro da tag <a>
• O título do livro do nó h3 a
• A imagem do livro do elemento .thumbnail
• A classificação do livro do elemento .star-rating
• O preço do produto do elemento .product_price .price_color
• A disponibilidade do produto do elemento .availability

Agora, implemente a lógica de raspagem dentro do loop:

const urlElement = await bookElement.locator("a").first();
const url = makeAbsoluteURL(
  await urlElement.getAttribute("href"),
  "https://books.toscrape.com/catalogue/"
);

const titleElement = await bookElement.locator("h3 a");
const title = await titleElement.getAttribute("title");

const imageElement = await bookElement.locator(".thumbnail");
const image = makeAbsoluteURL(
  await imageElement.getAttribute("src"),
  "https://books.toscrape.com/"
);

const ratingElement = await bookElement.locator(".star-rating");
const ratingClass = await ratingElement.getAttribute("class");
let rating;
switch (true) {
  case ratingClass.includes("One"):
    rating = 1;
    break;
  case ratingClass.includes("Two"):
    rating = 2;
    break;
  case ratingClass.includes("Three"):
    rating = 3;
    break;
  case ratingClass.includes("Four"):
    rating = 4;
    break;
  case ratingClass.includes("Five"):
    rating = 5;
    break;
  default:
    rating = null;
}

const priceElement = await bookElement.locator(
  ".product_price .price_color"
);
const price = (await priceElement.textContent()).trim();

const availabilityElement = await bookElement.locator(".availability");
const availability = (await availabilityElement.textContent()).trim();

O snippet acima usa as funções getAttribute() e textContent() do Playwright para extrair atributos HTML específicos e texto de nós HTML, respectivamente. Observe a lógica personalizada para recuperar a pontuação de classificação.

Além disso, como os URLs na página são relativos, eles podem ser convertidos em URLs absolutos usando a seguinte função personalizada:

function makeAbsoluteURL(url, baseURL) {
  // use a regular expression to remove any ../ or ../../ patterns
  const cleanURL = url.replace(/(\.\.\/)+/, "");

  // combine the base URL with the cleaned relative URL
  return baseURL + cleanURL;
}

Em seguida, preencha um novo objeto com os dados extraídos e adicione-o à matriz de livros:

const book = {
  "url": url,
  "title": title,
  "image": image,
  "rating": rating,
  "price": price,
  "availability": availability,
};
books.push(book);

Perfeito! A lógica de raspagem do Playwright agora está completa.

Etapa 4: implementar a lógica de rastreamento

Se você der uma olhada no site de destino, perceberá que algumas páginas têm um botão “próximo” na parte inferior:

Clicar nele carrega a próxima página. Observe que a última página de paginação não a inclui por motivos óbvios.

Assim, você pode implementar a lógica de rastreamento da Web com um loop while (verdadeiro) que:

1. Extrai dados da página atual
2. Clica no botão “próximo” se ele estiver presente e aguarda o carregamento da nova página
3. Repete o processo até que o botão “next” não seja mais encontrado

Veja a seguir como você pode conseguir isso:

while (true) {
  // select the book elements ...

  // select the "next" button and check if it is on the page
  const nextElement = await page.locator("li.next a");
  if ((await nextElement.count()) !== 0) {
    // click the "next" button and go to the next page
    await nextElement.click();
    // wait for the page to have been loaded
    await page.waitForLoadState("domcontentloaded")
  } else {
    break;
  }
}

Excelente! Lógica de rastreamento implementada.

Etapa 5: Exportar para CSV

A última etapa é exportar os dados extraídos para um arquivo CSV. Embora você possa fazer isso usando o Node.js básico, é muito mais fácil com uma biblioteca dedicada, como a fast-csv.

Instale o pacote fast-csv executando o seguinte comando:

npm install fast-csv

No início de seu arquivo scraping.js, importe os módulos necessários:

const { writeToPath } = require("fast-csv");

Em seguida, use o seguinte snippet para gravar os dados extraídos em um arquivo CSV:

writeToPath("books.csv", books, { headers: true });

E pronto! O script de raspagem da Web do Playwright está pronto.

Etapa nº 6: Juntar tudo

Seu arquivo script.js deve conter:

const { chromium } = require("playwright");
const { writeToPath } = require("fast-csv");

(async () => {
  // initialize a Chromium browser
  const browser = await chromium.launch({
    headless: false, // comment out in production
  });

  // initialize a new page in the browser
  const page = await browser.newPage();

  // visit the target page
  await page.goto(
    "https://books.toscrape.com/catalogue/category/books/fantasy_19/index.html"
  );

  // where to store the scraped data
  books = [];

  while (true) {
    // select the book elements
    const bookElements = await page.locator(".product_pod").all();
    // iterate over them to extract data from them
    for (const bookElement of bookElements) {
      // data extraction logic
      const urlElement = await bookElement.locator("a").first();
      const url = makeAbsoluteURL(
        await urlElement.getAttribute("href"),
        "https://books.toscrape.com/catalogue/"
      );

      const titleElement = await bookElement.locator("h3 a");
      const title = await titleElement.getAttribute("title");

      const imageElement = await bookElement.locator(".thumbnail");
      const image = makeAbsoluteURL(
        await imageElement.getAttribute("src"),
        "https://books.toscrape.com/"
      );

      const ratingElement = await bookElement.locator(".star-rating");
      const ratingClass = await ratingElement.getAttribute("class");
      let rating;
      switch (true) {
        case ratingClass.includes("One"):
          rating = 1;
          break;
        case ratingClass.includes("Two"):
          rating = 2;
          break;
        case ratingClass.includes("Three"):
          rating = 3;
          break;
        case ratingClass.includes("Four"):
          rating = 4;
          break;
        case ratingClass.includes("Five"):
          rating = 5;
          break;
        default:
          rating = null;
      }

      const priceElement = await bookElement.locator(
        ".product_price .price_color"
      );
      const price = (await priceElement.textContent()).trim();

      const availabilityElement = await bookElement.locator(".availability");
      const availability = (await availabilityElement.textContent()).trim();

      // populate a new book item with the scraped data and
      // then add it to the array
      const book = {
        "url": url,
        "title": title,
        "image": image,
        "rating": rating,
        "price": price,
        "availability": availability,
      };
      books.push(book);
    }

    // select the "next" button and check if it is on the page
    const nextElement = await page.locator("li.next a");
    if ((await nextElement.count()) !== 0) {
      // click the "next" button and go to the next page
      await nextElement.click();
      // wait for the page to have been loaded
      await page.waitForLoadState("domcontentloaded");
    } else {
      break;
    }
  }

  // export the scraped data to CSV
  writeToPath("books.csv", books, { headers: true });

  // close the browser and release resources
  await browser.close();
})();

function makeAbsoluteURL(url, baseURL) {
  // use a regular expression to remove any ../ or ../../ patterns
  const cleanURL = url.replace(/(\.\.\/)+/, "");

  // combine the base URL with the cleaned relative URL
  return baseURL + cleanURL;
}

Inicie-o com este comando do Node.js:

node script.js

O resultado será o seguinte arquivo books.csv:

Missão concluída! Agora, é hora de ver como obter o mesmo resultado com o Scrapy.

Como usar o Scrapy para raspagem da Web

Siga as etapas abaixo e veja como criar um raspador da Web simples com o Scrapy. Para obter mais orientações, confira nosso tutorial sobre raspagem da Web com o Scrapy.

Etapa 1: Configuração do projeto

Antes de começar, verifique se você tem o Python 3 instalado localmente. Caso contrário, faça o download no site oficial e instale-o.

Crie uma pasta para seu projeto e inicialize um ambiente virtual dentro dela:

mkdir scrapy-scraper
cd scrapy-scraper
python -m venv venv

No Windows, execute o seguinte comando para ativar o ambiente:

venv\Scripts\activate

De forma equivalente, no Unix ou no macOS, execute:

source venv/bin/activate

Em um ambiente ativado, instale o Scrapy com:

pip install scrapy

Em seguida, execute o comando abaixo para criar um projeto Scrapy chamado “books_scraper”:

scrapy startproject books_scraper

Muito bom! Você está pronto para fazer raspagem da Web com o Scrapy.

Etapa 2: criar a aranha Scrapy

Entre na pasta do projeto Scrapy e gere uma nova aranha para o site de destino:

cd books_scraper
scrapy genspider books books.toscrape.com

O Scrapy criará automaticamente todos os arquivos necessários para você. Especificamente, o diretório books_scraper agora deve conter a seguinte estrutura de arquivos:

books_scraper/
   │── __init__.py
   │── items.py
   │── middlewares.py
   │── pipelines.py
   │── settings.py
   └── spiders/
       │── __init__.py
       └── books.py

Para implementar a lógica de raspagem desejada, substitua o conteúdo de books_scraper/spiders/books.py pelo seguinte código:

import scrapy

class BooksSpider(scrapy.Spider):
    name = "books"
    allowed_domains = ["books.toscrape.com"]
    start_urls = ["https://books.toscrape.com/catalogue/page-1.html"]

    def parse(self, response):
        # Extract book details
        for book in response.css(".product_pod"):
            yield {
                "title": book.css("h3 a::attr(title)").get(),
                "url": response.urljoin(book.css("h3 a::attr(href)").get()),
                "image": response.urljoin(book.css(".thumbnail::attr(src)").get()),
                "rating": book.css(".star-rating::attr(class)").get().split()[-1],
                "price": book.css(".product_price .price_color::text").get(),
                "availability": book.css(".availability::text").get().strip(),
            }

        # Handle pagination
        next_page = response.css("li.next a::attr(href)").get()
        if next_page:
            yield response.follow(next_page, callback=self.parse)

Etapa 3: Iniciar o Spider

Na pasta books_scraper, em um ambiente virtual ativado, execute o seguinte comando para executar o spider do Scrapy e exportar os dados extraídos para um arquivo CSV:

scrapy crawl books -o books.csv

Isso gerará um arquivo books.csv contendo os dados extraídos, exatamente como o produzido pelo script Playwright. Mais uma vez, missão concluída!

Scrapy vs Playwright: Qual deles usar?

O script de raspagem do Playwright exigiu seis etapas longas, enquanto o Scrapy precisou de apenas três. Isso não é surpreendente, pois o Scrapy foi projetado para raspagem da Web, enquanto o Playwright é uma ferramenta geral de automação do navegador usada para testes e raspagem.

Em particular, a principal diferença estava na lógica de rastreamento da Web. O Playwright exigia interações manuais e lógica personalizada para paginação, enquanto o Scrapy pode lidar com isso com apenas algumas linhas de código.

Em resumo, escolha o Scrapy em vez do Playwright em um desses cenários:

1. Você precisa de extração de dados em grande escala com suporte de rastreamento integrado.
2. O desempenho e a velocidade são prioridades, pois o Scrapy é otimizado para solicitações rápidas e paralelas.
3. Você prefere uma estrutura que lide com paginação, novas tentativas, extração de dados em vários formatos e raspagem paralela para você.

Pelo contrário, prefiro o Playwright ao Scrapy quando:

1. Você precisa extrair dados de sites com muito JavaScript que exigem a renderização do navegador.
2. São necessárias interações dinâmicas, como a rolagem infinita.
3. Deseja ter mais controle sobre as interações do usuário (por exemplo, em padrões de navegação complexos de raspagem da Web).

Como etapa final desta comparação entre o Scrapy e o Playwright, consulte a tabela de resumo abaixo:

Limitações do dramaturgo e da sucata

Tanto o Scrapy quanto o Playwright são ferramentas poderosas para raspagem da Web, mas cada um deles tem certas limitações.

O Scrapy, por exemplo, tem dificuldades para extrair conteúdo dinâmico de sites que dependem de JavaScript para renderização ou recuperação de dados. Como muitos sites modernos agora exigem JavaScript, o Scrapy é mais vulnerável a medidas comuns de antirraspagem. É claro que o Playwright pode lidar com sites com muito JavaScript, mas enfrenta desafios como proibições de IP.

Ao fazer muitas solicitações, você pode acionar os limitadores de taxa, levando a recusas de solicitação ou até mesmo a proibições de IP. Para atenuar isso, você pode integrar um servidor proxy para alternar os IPs.

Se você precisar de servidores proxy confiáveis, 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. Sua 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.

Outro desafio com o Playwright são os CAPTCHAs, que são projetados para bloquear bots de raspagem automatizados que operam em navegadores. Para superá-los, você pode explorar soluções para contornar CAPTCHAs no Playwright.

Conclusão

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

O Scrapy fornece tudo o que você precisa para analisar dados e rastrear sites, enquanto o Playwright está mais voltado para a simulação de interações do usuário.

Você também descobriu suas limitações, como proibições de IP e CAPTCHAs. Felizmente, esses desafios podem ser superados usando proxies ou soluções anti-bot dedicadas, como o CAPTCHA Solver da Bright Data.

Crie uma conta gratuita na Bright Data hoje mesmo para explorar nossas soluções de proxy e raspagem!