Marionnettiste vs Selenium : que choisir pour le Web Scraping ?

Essayez-vous de choisir entre Puppeteer et Selenium pour le web scraping ? Les deux sont de puissants frameworks d’automatisation de navigateur, et faire le bon choix dépend de vos besoins spécifiques en matière de scraping et des ressources disponibles.

Pour vous aider à prendre une décision éclairée, nous avons mis en évidence les principales différences entre Puppeteer et Selenium dans le tableau ci-dessous. Ensuite, nous entrerons dans les détails et fournirons un exemple de scraping pour chaque framework afin de démontrer leur efficacité dans l'extraction de données à partir de pages Web.

Examinons ces bibliothèques en détail et effectuons un exemple de scraping avec chacune pour illustrer leur efficacité dans l'extraction de données d'une page Web.

Marionnettiste

Marionnettiste est une bibliothèque Node.js qui fournit une API de haut niveau pour contrôler Chrome ou Chromium via le protocole DevTools. Il est conçu pour automatiser des tâches dans Chrome ou Chromium, telles que la prise de captures d'écran, la génération de PDF et la navigation dans les pages.

Puppeteer peut également être utilisé pour tester des pages Web en simulant les interactions des utilisateurs, comme cliquer sur des boutons, remplir des formulaires et vérifier les résultats affichés.

Avantages du marionnettiste

• Facilité d'utilisation: Simple et direct à utiliser.
• Livré avec Chrome: Aucune configuration supplémentaire n’est requise.
• Mode sans tête: Fonctionne en mode sans tête par défaut mais peut être configuré pour s'exécuter en mode navigateur complet.
• Architecture pilotée par les événements: Élimine le besoin d’appels de mise en veille manuels dans votre code.
• Capacités complètes: Peut prendre des captures d'écran, générer des PDF et automatiser toutes les actions du navigateur.
• Gestion des performances: Propose des outils pour enregistrer le temps d'exécution et les performances de chargement afin d'optimiser et de déboguer votre scraper.
• SPA Rampant: Capable d'explorer des applications à page unique (SPA) et de générer du contenu pré-rendu (rendu côté serveur).
• Enregistrement de scripts: Permet de créer des scripts Puppeteer en enregistrant des actions sur le navigateur à l'aide de la console DevTools.

Inconvénients du marionnettiste

• Prise en charge limitée du navigateur: Prend en charge moins de navigateurs par rapport à Selenium.
• Axé sur JavaScript: Prend principalement en charge JavaScript, bien qu'il existe des ports non officiels pour Python et PHP.

Exemple de Web Scraping avec Puppeteer

Passons en revue un didacticiel de scraping Web Puppeteer pour extraire des éléments de la catégorie Crime et Thriller du site Web du Danube.

Boutique Danube : crime et thrillers

Pour commencer, importez le module Puppeteer et créez une fonction asynchrone pour exécuter le code 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();

Production attendue

Lorsque vous exécutez le code, le résultat doit ressembler à ce qui suit :

[
    {
        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 autre exemple d'utilisation de Marionnettiste

En plus de récupérer les données des pages Web, Puppeteer peut être utilisé pour diverses tâches d'automatisation. Un cas d'utilisation courant consiste à générer un PDF d'une page Web. Passons en revue un exemple dans lequel Puppeteer est utilisé pour générer un PDF à partir d'une page Web.

Générer un PDF avec Puppeteer

Étape 1 : Importer Puppeteer et créer une fonction asynchrone

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

Options supplémentaires pour le marionnettiste

Puppeteer propose plusieurs options pour générer des PDF qui peuvent être personnalisés en fonction de vos besoins. Voici quelques-unes des options que vous pouvez utiliser :

• path: Le chemin du fichier pour enregistrer le PDF.
• format: Le format du papier (par exemple, 'A4', 'Lettre').
• printBackground: s'il faut inclure les graphiques d'arrière-plan.
• landscape: Mis à true pour une orientation paysage.
• margin: Spécifiez les marges du PDF (haut, droite, bas, gauche).

Exemple avec des options supplémentaires :

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

Exemple de sortie

L'exécution du code ci-dessus créera un fichier PDF nommé example.pdf dans le répertoire courant avec le contenu de la page web https://example.com.

Puppeteer est un outil polyvalent pour les tâches d'automatisation Web, de la récupération de données à la génération de PDF. Sa facilité d'utilisation et ses fonctionnalités puissantes en font un excellent choix pour automatiser un large éventail d'activités du navigateur. Que vous récupériez des données, génériez des rapports ou testiez des pages Web, Puppeteer fournit les outils dont vous avez besoin pour accomplir votre travail efficacement.

Sélénium

Sélénium est un outil open source de test de bout en bout et d'automatisation Web souvent utilisé pour le web scraping. Ses principaux composants incluent Selenium IDE, Selenium WebDriver et Selenium Grid.

• IDE sélénium: Utilisé pour enregistrer les actions avant de les automatiser.
• Pilote Web Sélénium: Exécute les commandes dans le navigateur.
• Grille de sélénium: Active l'exécution parallèle.

Avantages du sélénium

• Facilité d'utilisation: Simple et direct à utiliser.
• Support linguistique: Prend en charge divers langages de programmation tels que Python, Java, JavaScript, Ruby et C#.
• Automatisation du navigateur: Peut automatiser les navigateurs comme Firefox, Edge, Safari et même les navigateurs QtWebKit personnalisés.
• Évolutivité: Possibilité de faire évoluer Selenium vers des centaines d'instances à l'aide de serveurs cloud avec différents paramètres de navigateur.
• Multiplateforme: Fonctionne sous Windows, macOS et Linux.

Inconvénients du sélénium

• Configuration complexe: Les méthodes de configuration de Selenium peuvent être complexes.

Échantillon de grattage Web avec du sélénium

Comme avec Puppeteer, passons en revue un tutoriel sur le web scraping avec Selenium en utilisant le même site cible. Nous extrairons les extraits de livres de la catégorie Crime et Thriller du site Web du Danube.

Boutique Danube : crime et thrillers

Étape 1 : importer les modules nécessaires et configurer Selenium

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

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

Étape 2 : initialiser le Chrome WebDriver

driver = webdriver.Chrome(options=options)

Étape 3 : Accédez au site Web cible

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

Étape 4 : Cliquez sur la catégorie Crime et thrillers et extrayez les aperçus du livre

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

Étape 5 : Définir une fonction pour extraire les données de chaque aperçu de livre

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}

Étape 6 : Parcourez les aperçus, extrayez les données et quittez le pilote

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

print(extracted_data)
driver.quit()

Production attendue

L'exécution du code ci-dessus produira un résultat similaire à celui-ci :

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

Exemple supplémentaire de sélénium : prendre une capture d'écran

En plus de récupérer des données, Selenium peut également être utilisé pour prendre des captures d'écran de pages Web. Voici un exemple de comment prendre une capture d'écran d'une page Web à l'aide de Selenium.

Étape 1 : importer les modules nécessaires et configurer Selenium

from selenium import webdriver

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

Étape 2 : initialiser le Chrome WebDriver

driver = webdriver.Chrome(options=options)

Étape 3 : Accédez au site Web cible

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

Étape 4 : prendre une capture d'écran

driver.save_screenshot("example_screenshot.png")

Étape 5 : Quittez le pilote

driver.quit()

Selenium est un outil polyvalent pour les tâches d'automatisation Web, notamment le web scraping et la prise de captures d'écran. Sa prise en charge de plusieurs langages de programmation et navigateurs, ainsi que son évolutivité, en font un choix puissant pour divers besoins d'automatisation. Que vous extrayiez des données ou génériez des rapports, Selenium offre les capacités nécessaires pour automatiser efficacement vos tâches.

Marionnettiste vs Selenium : comparaison de vitesse

Puppeteer est-il plus rapide que Selenium ? La réponse est oui : Puppeteer est généralement plus rapide que Selenium.

Pour comparer la vitesse de Puppeteer et Selenium, nous avons utilisé le bac à sable du Danube-store et exécuté les scripts présentés ci-dessus 20 fois, en faisant la moyenne des temps d'exécution.

Test de vitesse au sélénium

Nous avons utilisé le time module en Python pour mesurer le temps d'exécution du script Selenium. L'heure de début a été enregistrée au début et l'heure de fin à la fin du script. La différence entre ces temps fournissait la durée totale d'exécution.

Voici le script complet utilisé pour 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()

Test de vitesse du marionnettiste

Pour le script Puppeteer, nous avons utilisé le Date objet pour mesurer le temps d’exécution. L'heure de début a été enregistrée au début et l'heure de fin à la fin du script. La différence entre ces temps fournissait la durée totale d'exécution.

Voici le script complet utilisé pour 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();

Résultats des tests de performances

Les tests de performances ont montré que Puppeteer est environ 60% plus rapide que Selenium. Cet avantage en termes de vitesse fait de Puppeteer un choix plus approprié pour les projets nécessitant un scraping et une automatisation Web à grande vitesse, en particulier lorsque vous travaillez avec des navigateurs basés sur Chromium.

Résumé des résultats de vitesse :

Le tableau ci-dessous illustre la différence de performances entre Puppeteer et Selenium :

La mise à l'échelle des applications Puppeteer pour les projets nécessitant un web scraping rapide et efficace est le choix optimal dans ce contexte.

Marionnettiste contre Sélénium : quel est le meilleur ?

Alors, lequel est le meilleur entre Selenium et Puppeteer pour le scraping ? Il n'y a pas de réponse directe à cette question car elle dépend de plusieurs facteurs, tels que la prise en charge à long terme de la bibliothèque, la prise en charge de plusieurs navigateurs et vos besoins en matière de web scraping.

Puppeteer est plus rapide, mais comparé à Selenium, il prend en charge moins de navigateurs. Selenium prend également en charge davantage de langages de programmation que Puppeteer.

Conclusion

Bien que l'utilisation de Puppeteer ou Selenium soit une bonne option pour le web scraping, la mise à l'échelle et l'optimisation de votre projet de web scraping peuvent s'avérer difficiles, car des mesures anti-bot avancées peuvent détecter et bloquer ces bibliothèques. La meilleure façon d’éviter cela est d’utiliser une API de web scraping, comme OneProxy.

Utiliser Puppeteer avec des serveurs proxy

Pour utiliser Puppeteer avec un serveur proxy, vous pouvez transmettre les paramètres proxy dans le args option lors du lancement de l’instance du navigateur. Voici un exemple :

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

Utiliser Selenium avec des serveurs proxy

Pour utiliser Selenium avec un serveur proxy, vous pouvez définir les options de proxy à l'aide du webdriver.Proxy classe. Voici un exemple :

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'utilisation de serveurs proxy avec Puppeteer et Selenium peut aider à contourner les restrictions basées sur l'adresse IP et à réduire le risque de blocage, améliorant ainsi l'efficacité de vos tâches de scraping Web. Les proxys tournants de OneProxy peut optimiser davantage ce processus, offrant une expérience de grattage transparente.