Puppeteer vs. Selenium: O que escolher para Web Scraping?

Você está tentando decidir entre Puppeteer e Selenium para web scraping? Ambas são estruturas poderosas de automação de navegador, e fazer a escolha certa depende de suas necessidades específicas de raspagem e dos recursos disponíveis.

Para ajudá-lo a tomar uma decisão informada, destacamos as principais diferenças entre o Puppeteer e o Selenium na tabela abaixo. Posteriormente, nos aprofundaremos nos detalhes e forneceremos um exemplo de scraping para cada estrutura para demonstrar sua eficácia na extração de dados de páginas da web.

Vamos discutir essas bibliotecas em detalhes e realizar um exemplo de scraping com cada uma para ilustrar sua eficiência na extração de dados de uma página da web.

Marionetista

Marionetista é uma biblioteca Node.js que fornece uma API de alto nível para controlar o Chrome ou Chromium através do protocolo DevTools. Ele foi projetado para automatizar tarefas no Chrome ou Chromium, como fazer capturas de tela, gerar PDFs e navegar em páginas.

O Puppeteer também pode ser usado para testar páginas da web, simulando interações do usuário, como clicar em botões, preencher formulários e verificar os resultados exibidos.

Vantagens do marionetista

• Fácil de usar: Simples e direto de usar.
• Empacotado com cromo: nenhuma configuração adicional é necessária.
• Modo sem cabeça: é executado no modo headless por padrão, mas pode ser configurado para ser executado no modo de navegador completo.
• Arquitetura Orientada a Eventos: elimina a necessidade de chamadas manuais de suspensão em seu código.
• Capacidades Abrangentes: pode fazer capturas de tela, gerar PDFs e automatizar todas as ações do navegador.
• Gestão de Desempenho: oferece ferramentas para registrar o tempo de execução e o desempenho de carga para otimizar e depurar seu scraper.
• Rastreamento de SPA: Capaz de rastrear aplicativos de página única (SPAs) e gerar conteúdo pré-renderizado (renderização no servidor).
• Gravação de roteiro: permite criar scripts do Puppeteer gravando ações no navegador usando o console do DevTools.

Desvantagens do titereiro

• Suporte limitado ao navegador: Suporta menos navegadores em comparação ao Selenium.
• Foco em JavaScript: suporta principalmente JavaScript, embora existam portas não oficiais para Python e PHP.

Exemplo de Web Scraping com Puppeteer

Vamos seguir um tutorial de web scraping do Puppeteer para extrair itens da categoria Crime e Thriller do site do Danúbio.

Loja do Danúbio: Crime e Suspense

Para começar, importe o módulo Puppeteer e crie uma função assíncrona para executar o código do Puppeteer:

const puppeteer = require('puppeteer'); 

async function main() { 
    // Launch a headless browser instance 
    const browser = await puppeteer.launch({ headless: true });

    // Create a new page object 
    const page = await browser.newPage();

    // Navigate to the target URL and wait until the loading finishes
    await page.goto('https://danube-webshop.herokuapp.com/', { waitUntil: 'networkidle2' });

    // Wait for the left-side bar to load
    await page.waitForSelector('ul.sidebar-list');

    // Click on the first element and wait for the navigation to finish
    await Promise.all([
        page.waitForNavigation(),
        page.click("ul[class='sidebar-list'] > li > a"),
    ]);

    // Wait for the book previews to load
    await page.waitForSelector("li[class='preview']");

    // Extract the book previews
    const books = await page.evaluateHandle(
        () => [...document.querySelectorAll("li[class='preview']")]
    );

    // Extract the relevant data using page.evaluate
    const processed_data = await page.evaluate(elements => {
        let data = [];
        elements.forEach(element => {
            let title = element.querySelector("div.preview-title").innerHTML;
            let author = element.querySelector("div.preview-author").innerHTML;
            let rating = element.querySelector("div.preview-details > p.preview-rating").innerHTML;
            let price = element.querySelector("div.preview-details > p.preview-price").innerHTML;

            let result = { title, author, rating, price };
            data.push(result);
        });
        return data;
    }, books);

    // Print out the extracted data
    console.log(processed_data);

    // Close the page and browser respectively
    await page.close();
    await browser.close();
}

// Run the main function to scrape the data
main();

Resultado Esperado

Ao executar o código, a saída deverá ser semelhante a esta:

[
    {
        title: 'Does the Sun Also Rise?',
        author: 'Ernst Doubtingway',
        rating: '★★★★☆',
        price: '$9.95'
    },
    {
        title: 'The Insiders',
        author: 'E. S. Hilton',
        rating: '★★★★☆',
        price: '$9.95'
    },
    {
        title: 'A Citrussy Clock',
        author: 'Bethany Urges',
        rating: '★★★★★',
        price: '$9.95'
    }
]

Outro exemplo de uso do titereiro

Além de extrair dados de páginas da web, o Puppeteer pode ser usado para uma variedade de tarefas de automação. Um caso de uso comum é gerar um PDF de uma página da web. Vejamos um exemplo em que o Puppeteer é usado para gerar um PDF a partir de uma página da web.

Gerando um PDF com o Puppeteer

Etapa 1: importar o Puppeteer e criar uma função assíncrona

const puppeteer = require('puppeteer');

async function generatePDF() {
    // Launch a headless browser instance
    const browser = await puppeteer.launch({ headless: true });

    // Create a new page object
    const page = await browser.newPage();

    // Navigate to the target URL
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });

    // Generate a PDF from the web page
    await page.pdf({
        path: 'example.pdf', // Output file path
        format: 'A4',        // Paper format
        printBackground: true, // Include background graphics
    });

    // Close the page and browser respectively
    await page.close();
    await browser.close();
}

// Run the function to generate the PDF
generatePDF();

Opções adicionais de marionetista

O Puppeteer oferece diversas opções para geração de PDFs que podem ser customizados para atender às suas necessidades. Aqui estão algumas das opções que você pode usar:

• path: O caminho do arquivo para salvar o PDF.
• format: O formato do papel (por exemplo, 'A4', 'Carta').
• printBackground: Se deseja incluir os gráficos de fundo.
• landscape: Definido como true para orientação paisagística.
• margin: Especifique as margens do PDF (superior, direita, inferior, esquerda).

Exemplo com opções adicionais:

const puppeteer = require('puppeteer');

async function generatePDF() {
    const browser = await puppeteer.launch({ headless: true });
    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });

    await page.pdf({
        path: 'example.pdf',
        format: 'A4',
        printBackground: true,
        landscape: true,
        margin: {
            top: '20px',
            right: '20px',
            bottom: '20px',
            left: '20px',
        },
    });

    await page.close();
    await browser.close();
}

generatePDF();

Exemplo de saída

A execução do código acima criará um arquivo PDF chamado example.pdf no diretório atual com o conteúdo da página web https://example.com.

Puppeteer é uma ferramenta versátil para tarefas de automação web, desde a coleta de dados até a geração de PDFs. Sua facilidade de uso e recursos poderosos o tornam uma excelente escolha para automatizar uma ampla gama de atividades do navegador. Esteja você coletando dados, gerando relatórios ou testando páginas da web, o Puppeteer fornece as ferramentas necessárias para realizar o trabalho com eficiência.

Selênio

Selênio é uma ferramenta de teste ponta a ponta de código aberto e ferramenta de automação da web frequentemente usada para web scraping. Seus principais componentes incluem Selenium IDE, Selenium WebDriver e Selenium Grid.

• IDE Selênio: Usado para registrar ações antes de automatizá-las.
• Selênio WebDriver: Executa comandos no navegador.
• Grade de Selênio: permite a execução paralela.

Vantagens do Selênio

• Fácil de usar: Simples e direto de usar.
• Suporte de linguas: Suporta várias linguagens de programação, como Python, Java, JavaScript, Ruby e C#.
• Automação do navegador: pode automatizar navegadores como Firefox, Edge, Safari e até navegadores QtWebKit personalizados.
• Escalabilidade: é possível escalar o Selenium para centenas de instâncias usando servidores em nuvem com diferentes configurações de navegador.
• Plataforma cruzada: Opera em Windows, macOS e Linux.

Desvantagens do selênio

• Configuração complexa: Os métodos de configuração do Selenium podem ser complexos.

Amostra de Web Scraping com Selenium

Assim como no Puppeteer, vamos fazer um tutorial sobre web scraping com Selenium usando o mesmo site de destino. Extrairemos as prévias dos livros da categoria Crime e Suspense do site do Danúbio.

Loja do Danúbio: Crime e Suspense

Etapa 1: importe os módulos necessários e configure o Selenium

import time
from selenium import webdriver
from selenium.webdriver.common.by import By

options = webdriver.ChromeOptions()
options.add_argument("--headless")

Etapa 2: inicializar o Chrome WebDriver

driver = webdriver.Chrome(options=options)

Etapa 3: navegue até o site de destino

time.sleep(1)
crime_n_thrillers = driver.find_element(By.CSS_SELECTOR, "ul[class='sidebar-list'] > li")
crime_n_thrillers.click()
time.sleep(1)
books = driver.find_elements(By.CSS_SELECTOR, "div.shop-content li.preview")

Etapa 4: clique na categoria Crime e Thrillers e extraia as prévias do livro

time.sleep(1)
crime_n_thrillers = driver.find_element(By.CSS_SELECTOR, "ul[class='sidebar-list'] > li")
crime_n_thrillers.click()
time.sleep(1)
books = driver.find_elements(By.CSS_SELECTOR, "div.shop-content li.preview")

Etapa 5: definir uma função para extrair dados de cada visualização de livro

def extract(element):
    title = element.find_element(By.CSS_SELECTOR, "div.preview-title").text
    author = element.find_element(By.CSS_SELECTOR, "div.preview-author").text
    rating = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-rating").text
    price = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-price").text
    return {"title": title, "author": author, "rating": rating, "price": price}

Etapa 6: percorrer as visualizações, extrair os dados e sair do driver

extracted_data = []
for element in books:
    data = extract(element)
    extracted_data.append(data)

print(extracted_data)
driver.quit()

Resultado Esperado

A execução do código acima produzirá uma saída semelhante à seguinte:

[
    {'title': 'Does the Sun Also Rise?', 'author': 'Ernst Doubtingway', 'rating': '★★★★☆', 'price': '$9.95'},
    {'title': 'The Insiders', 'author': 'E. S. Hilton', 'rating': '★★★★☆', 'price': '$9.95'},
    {'title': 'A Citrussy Clock', 'author': 'Bethany Urges', 'rating': '★★★★★', 'price': '$9.95'}
]

Exemplo adicional de Selenium: captura de tela

Além de extrair dados, o Selenium também pode ser usado para fazer capturas de tela de páginas da web. Aqui está um exemplo de como fazer uma captura de tela de uma página da web usando Selenium.

Etapa 1: importe os módulos necessários e configure o Selenium

from selenium import webdriver

options = webdriver.ChromeOptions()
options.add_argument("--headless")

Etapa 2: inicializar o Chrome WebDriver

driver = webdriver.Chrome(options=options)

Etapa 3: navegue até o site de destino

url = "https://example.com"
driver.get(url)

Etapa 4: faça uma captura de tela

driver.save_screenshot("example_screenshot.png")

Etapa 5: saia do driver

driver.quit()

Selenium é uma ferramenta versátil para tarefas de automação web, incluindo web scraping e captura de tela. Seu suporte para múltiplas linguagens de programação e navegadores, juntamente com sua escalabilidade, o tornam uma escolha poderosa para diversas necessidades de automação. Esteja você extraindo dados ou gerando relatórios, o Selenium oferece recursos para automatizar suas tarefas com eficiência.

Titereiro vs. Selênio: comparação de velocidade

O Puppeteer é mais rápido que o Selenium? A resposta é sim – o Puppeteer geralmente é mais rápido que o Selenium.

Para comparar a velocidade do Puppeteer e do Selenium, usamos o sandbox Danube-store e executamos os scripts apresentados acima 20 vezes, calculando a média dos tempos de execução.

Teste de velocidade de selênio

Nós usamos o time módulo em Python para medir o tempo de execução do script Selenium. O horário de início foi registrado no início e o horário de término no final do roteiro. A diferença entre esses tempos forneceu a duração total da execução.

Aqui está o script completo usado para Selenium:

import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def extract(element):
    title = element.find_element(By.CSS_SELECTOR, "div.preview-title").text
    author = element.find_element(By.CSS_SELECTOR, "div.preview-author").text
    rating = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-rating").text
    price = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-price").text
    return {"title": title, "author": author, "rating": rating, "price": price}

# Start the timer
start_time = time.time()

options = webdriver.ChromeOptions()
options.add_argument("--headless")

# Create a new instance of the Chrome driver
driver = webdriver.Chrome(options=options)

url = "https://danube-webshop.herokuapp.com/"
driver.get(url)

# Click on the Crime & Thrillers category
time.sleep(1)
crime_n_thrillers = driver.find_element(By.CSS_SELECTOR, "ul[class='sidebar-list'] > li")
crime_n_thrillers.click()
time.sleep(1)

# Extract the book previews
books = driver.find_elements(By.CSS_SELECTOR, "div.shop-content li.preview")

extracted_data = []
for element in books:
    data = extract(element)
    extracted_data.append(data)

print(extracted_data)

# End the timer
end_time = time.time()
print(f"The whole script took: {end_time - start_time:.4f} seconds")

driver.quit()

Teste de velocidade do titereiro

Para o roteiro do Puppeteer, usamos o Date objeto para medir o tempo de execução. O horário de início foi registrado no início e o horário de término no final do roteiro. A diferença entre esses tempos forneceu a duração total da execução.

Aqui está o script completo usado para Puppeteer:

const puppeteer = require('puppeteer');

async function main() {
    const start = Date.now();

    const browser = await puppeteer.launch({ headless: true });
    const page = await browser.newPage();
    await page.goto('https://danube-webshop.herokuapp.com/', { waitUntil: 'networkidle2' });

    await page.waitForSelector('ul.sidebar-list');

    await Promise.all([
        page.waitForNavigation(),
        page.click("ul[class='sidebar-list'] > li > a"),
    ]);

    await page.waitForSelector("li[class='preview']");
    const books = await page.evaluateHandle(
        () => [...document.querySelectorAll("li[class='preview']")]
    );

    const processed_data = await page.evaluate(elements => {
        let data = [];
        elements.forEach(element => {
            let title = element.querySelector("div.preview-title").innerHTML;
            let author = element.querySelector("div.preview-author").innerHTML;
            let rating = element.querySelector("div.preview-details > p.preview-rating").innerHTML;
            let price = element.querySelector("div.preview-details > p.preview-price").innerHTML;

            let result = { title, author, rating, price };
            data.push(result);
        });
        return data;
    }, books);

    console.log(processed_data);
    await page.close();
    await browser.close();

    const end = Date.now();
    console.log(`Execution time: ${(end - start) / 1000} seconds`);
}

main();

Resultados do teste de desempenho

Os testes de desempenho mostraram que o Puppeteer é cerca de 60% mais rápido que o Selenium. Essa vantagem de velocidade torna o Puppeteer uma escolha mais adequada para projetos que exigem web scraping e automação de alta velocidade, especialmente ao trabalhar com navegadores baseados em Chromium.

Resumo dos resultados de velocidade:

O gráfico abaixo ilustra a diferença de desempenho entre Puppeteer e Selenium:

Ampliar aplicativos Puppeteer para projetos que exigem web scraping rápido e eficiente é a escolha ideal neste contexto.

Marionetista vs. Selênio: o que é melhor?

Então, qual é o melhor entre Selenium e Puppeteer para raspagem? Não há uma resposta direta para essa pergunta, pois ela depende de vários fatores, como suporte de biblioteca de longo prazo, suporte entre navegadores e suas necessidades de web scraping.

O Puppeteer é mais rápido, mas comparado ao Selenium, suporta menos navegadores. O Selenium também suporta mais linguagens de programação em comparação com o Puppeteer.

Conclusão

Embora usar Puppeteer ou Selenium seja uma boa opção para web scraping, ampliar e otimizar seu projeto de web scraping pode ser um desafio porque medidas anti-bot avançadas podem detectar e bloquear essas bibliotecas. A melhor maneira de evitar isso é usar uma API de web scraping, como OneProxy.

Usando o Puppeteer com servidores proxy

Para usar o Puppeteer com um servidor proxy, você pode passar as configurações de proxy no args opção ao iniciar a instância do navegador. Aqui está um exemplo:

const puppeteer = require('puppeteer');

async function main() {
    const proxyServer = 'http://your-proxy-server:port';
    
    const browser = await puppeteer.launch({
        headless: true,
        args: [`--proxy-server=${proxyServer}`]
    });

    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });

    // Perform your web scraping tasks here

    await browser.close();
}

main();

Usando Selenium com servidores proxy

Para usar o Selenium com um servidor proxy, você pode definir as opções de proxy usando o webdriver.Proxy aula. Aqui está um exemplo:

from selenium import webdriver
from selenium.webdriver.common.proxy import Proxy, ProxyType

proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy = "your-proxy-server:port"
proxy.ssl_proxy = "your-proxy-server:port"

capabilities = webdriver.DesiredCapabilities.CHROME
proxy.add_to_capabilities(capabilities)

options = webdriver.ChromeOptions()
options.add_argument("--headless")

driver = webdriver.Chrome(desired_capabilities=capabilities, options=options)
driver.get("https://example.com")

# Perform your web scraping tasks here

driver.quit()

O uso de servidores proxy com Puppeteer e Selenium pode ajudar a contornar restrições baseadas em IP e reduzir o risco de bloqueio, aumentando a eficiência de suas tarefas de web scraping. Proxies rotativos do OneProxy pode otimizar ainda mais esse processo, proporcionando uma experiência de raspagem perfeita.