Burattinaio contro selenio: cosa scegliere per il web scraping?

Stai cercando di decidere tra Puppeteer e Selenium per il web scraping? Entrambi sono potenti framework di automazione del browser e fare la scelta giusta dipende dalle tue specifiche esigenze di scraping e dalle risorse disponibili.

Per aiutarti a prendere una decisione informata, abbiamo evidenziato le principali differenze tra Puppeteer e Selenium nella tabella seguente. Successivamente, approfondiremo i dettagli e forniremo un esempio di scraping per ciascun framework per dimostrare la loro efficacia nell'estrazione di dati dalle pagine web.

Procediamo a discutere queste librerie in dettaglio ed eseguiamo un esempio di scraping con ciascuna per illustrare la loro efficienza nell'estrazione di dati da una pagina web.

Burattinaio

Burattinaio è una libreria Node.js che fornisce un'API di alto livello per controllare Chrome o Chromium tramite il protocollo DevTools. È progettato per automatizzare le attività in Chrome o Chromium, come acquisire screenshot, generare PDF e navigare tra le pagine.

Puppeteer può essere utilizzato anche per testare pagine Web simulando le interazioni dell'utente come fare clic sui pulsanti, compilare moduli e verificare i risultati visualizzati.

Vantaggi del burattinaio

• Facilità d'uso: Semplice e immediato da usare.
• In bundle con Chromium: non è richiesta alcuna configurazione aggiuntiva.
• Modalità senza testa: viene eseguito in modalità headless per impostazione predefinita, ma può essere configurato per l'esecuzione in modalità browser completo.
• Architettura guidata dagli eventi: elimina la necessità di chiamate di sospensione manuali nel codice.
• Funzionalità complete: può acquisire screenshot, generare PDF e automatizzare tutte le azioni del browser.
• Gestione delle prestazioni: offre strumenti per la registrazione del tempo di esecuzione e delle prestazioni di carico per ottimizzare ed eseguire il debug del tuo scraper.
• Scansione della SPA: in grado di eseguire la scansione di applicazioni a pagina singola (SPA) e di generare contenuti pre-renderizzati (rendering lato server).
• Registrazione della sceneggiatura: consente di creare script Puppeteer registrando azioni sul browser utilizzando la console DevTools.

Svantaggi del burattinaio

• Supporto browser limitato: Supporta meno browser rispetto a Selenium.
• Focalizzato su JavaScript: supporta principalmente JavaScript, sebbene esistano port non ufficiali per Python e PHP.

Esempio di web scraping con Puppeteer

Esaminiamo un tutorial sul web scraping di Puppeteer per estrarre elementi dalla categoria Crime e Thriller del sito web di Danube.

Negozio del Danubio: crimine e thriller

Per iniziare, importa il modulo Puppeteer e crea una funzione asincrona per eseguire il codice 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();

Risultato previsto

Quando esegui il codice, l'output dovrebbe essere simile al seguente:

[
    {
        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'
    }
]

Un altro esempio di utilizzo di Puppeteer

Oltre a raccogliere dati dalle pagine Web, Puppeteer può essere utilizzato per una varietà di attività di automazione. Un caso d'uso comune è generare un PDF di una pagina web. Esaminiamo un esempio in cui Puppeteer viene utilizzato per generare un PDF da una pagina web.

Generazione di un PDF con Puppeteer

Passaggio 1: importa Puppeteer e crea una funzione asincrona

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();

Opzioni aggiuntive del burattinaio

Puppeteer offre diverse opzioni per generare PDF che possono essere personalizzati in base alle proprie esigenze. Ecco alcune delle opzioni che puoi utilizzare:

• path: il percorso del file in cui salvare il PDF.
• format: il formato della carta (ad esempio, "A4", "Lettera").
• printBackground: se includere la grafica di sfondo.
• landscape: Impostato true per l'orientamento orizzontale.
• margin: specifica i margini per il PDF (in alto, a destra, in basso, a sinistra).

Esempio con opzioni aggiuntive:

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();

Esempio di output

L'esecuzione del codice sopra creerà un file PDF denominato example.pdf nella directory corrente con il contenuto della pagina web https://example.com.

Puppeteer è uno strumento versatile per attività di automazione web, dallo scraping di dati alla generazione di PDF. La sua facilità d'uso e le sue potenti funzionalità lo rendono una scelta eccellente per automatizzare un'ampia gamma di attività del browser. Che tu stia raccogliendo dati, generando report o testando pagine web, Puppeteer fornisce gli strumenti necessari per svolgere il lavoro in modo efficiente.

Selenio

Selenio è uno strumento di test end-to-end open source e di automazione web spesso utilizzato per il web scraping. I suoi componenti principali includono Selenium IDE, Selenium WebDriver e Selenium Grid.

• IDE di selenio: Utilizzato per registrare le azioni prima di automatizzarle.
• Selenio WebDriver: Esegue i comandi nel browser.
• Griglia di selenio: Abilita l'esecuzione parallela.

Vantaggi del selenio

• Facilità d'uso: Semplice e immediato da usare.
• Supporto linguistico: Supporta vari linguaggi di programmazione come Python, Java, JavaScript, Ruby e C#.
• Automazione del browser: può automatizzare browser come Firefox, Edge, Safari e persino browser QtWebKit personalizzati.
• Scalabilità: È possibile scalare Selenium a centinaia di istanze utilizzando server cloud con diverse impostazioni del browser.
• Multipiattaforma: funziona su Windows, macOS e Linux.

Svantaggi del selenio

• Configurazione complessa: I metodi di configurazione del selenio possono essere complessi.

Esempio di web scraping con selenio

Come con Puppeteer, seguiamo un tutorial sul web scraping con Selenium utilizzando lo stesso sito di destinazione. Estrarremo le anteprime dei libri dalla categoria Crime e Thriller del sito Danube.

Negozio del Danubio: crimine e thriller

Passaggio 1: importa i moduli necessari e configura Selenium

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

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

Passaggio 2: inizializza Chrome WebDriver

driver = webdriver.Chrome(options=options)

Passaggio 3: accedere al sito Web di destinazione

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")

Passaggio 4: fai clic sulla categoria Crime e thriller ed estrai le anteprime dei libri

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")

Passaggio 5: definire una funzione per estrarre i dati da ciascuna anteprima del libro

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}

Passaggio 6: scorrere le anteprime, estrarre i dati e chiudere il driver

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

print(extracted_data)
driver.quit()

Risultato previsto

L'esecuzione del codice sopra produrrà un output simile al seguente:

[
    {'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'}
]

Esempio aggiuntivo di selenio: acquisire uno screenshot

Oltre a raschiare dati, Selenium può essere utilizzato anche per acquisire screenshot di pagine web. Ecco un esempio di come acquisire uno screenshot di una pagina Web utilizzando Selenium.

Passaggio 1: importa i moduli necessari e configura Selenium

from selenium import webdriver

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

Passaggio 2: inizializza Chrome WebDriver

driver = webdriver.Chrome(options=options)

Passaggio 3: accedere al sito Web di destinazione

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

Passaggio 4: fai uno screenshot

driver.save_screenshot("example_screenshot.png")

Passaggio 5: uscire dal driver

driver.quit()

Selenium è uno strumento versatile per attività di automazione web, tra cui web scraping e acquisizione di screenshot. Il suo supporto per più linguaggi di programmazione e browser, insieme alla sua scalabilità, lo rendono una scelta potente per varie esigenze di automazione. Che tu stia estraendo dati o generando report, Selenium offre le funzionalità per automatizzare le tue attività in modo efficiente.

Burattinaio contro selenio: confronto di velocità

Puppeteer è più veloce del selenio? La risposta è sì: il burattinaio è generalmente più veloce del selenio.

Per confrontare la velocità di Puppeteer e Selenium, abbiamo utilizzato il sandbox del Danube-store ed eseguito gli script presentati sopra 20 volte, calcolando la media dei tempi di esecuzione.

Test di velocità del selenio

Abbiamo usato il time modulo in Python per misurare il tempo di esecuzione dello script Selenium. L'ora di inizio è stata registrata all'inizio e l'ora di fine alla fine dello script. La differenza tra questi tempi ha fornito la durata totale dell'esecuzione.

Ecco lo script completo utilizzato per 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()

Prova di velocità del burattinaio

Per la sceneggiatura di Puppeteer, abbiamo utilizzato il file Date oggetto per misurare il tempo di esecuzione. L'ora di inizio è stata registrata all'inizio e l'ora di fine alla fine dello script. La differenza tra questi tempi ha fornito la durata totale dell'esecuzione.

Ecco lo script completo utilizzato per 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();

Risultati dei test sulle prestazioni

I test sulle prestazioni hanno dimostrato che Puppeteer è circa 60% più veloce del Selenium. Questo vantaggio in termini di velocità rende Puppeteer una scelta più adatta per progetti che richiedono web scraping e automazione ad alta velocità, soprattutto quando si lavora con browser basati su Chromium.

Riepilogo dei risultati di velocità:

La tabella seguente illustra la differenza di prestazioni tra Puppeteer e Selenium:

L'ampliamento delle applicazioni Puppeteer per progetti che richiedono web scraping rapido ed efficiente è la scelta ottimale in questo contesto.

Burattinaio contro selenio: quale è meglio?

Quindi quale è meglio tra Selenium e Puppeteer per lo scraping? Non esiste una risposta diretta a questa domanda poiché dipende da molteplici fattori, come il supporto della libreria a lungo termine, il supporto di più browser e le esigenze di web scraping.

Puppeteer è più veloce, ma rispetto a Selenium supporta meno browser. Selenium supporta anche più linguaggi di programmazione rispetto a Puppeteer.

Conclusione

Sebbene l'utilizzo di Puppeteer o Selenium sia una buona opzione per il web scraping, espandere e ottimizzare il tuo progetto di web scraping può essere impegnativo perché misure anti-bot avanzate possono rilevare e bloccare queste librerie. Il modo migliore per evitarlo è utilizzare un'API di web scraping, come OneProxy.

Utilizzo di Puppeteer con server proxy

Per utilizzare Puppeteer con un server proxy, puoi passare le impostazioni proxy nel file args opzione all'avvio dell'istanza del browser. Ecco un esempio:

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();

Utilizzo del selenio con server proxy

Per utilizzare Selenium con un server proxy, è possibile impostare le opzioni proxy utilizzando il file webdriver.Proxy classe. Ecco un esempio:

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()

L'utilizzo di server proxy con Puppeteer e Selenium può aiutarti a bypassare le restrizioni basate su IP e ridurre il rischio di essere bloccato, migliorando l'efficienza delle tue attività di web scraping. I proxy rotanti di OneProxy può ottimizzare ulteriormente questo processo, fornendo un'esperienza di raschiatura senza interruzioni.