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.
Critères | Marionnettiste | Sélénium |
---|---|---|
Langues compatibles | Seul JavaScript est officiellement pris en charge, mais il existe des ports PHP et Python non officiels. | Java, Python, C#, Ruby, PHP, JavaScript et Kotlin |
Prise en charge du navigateur | Prise en charge de Chrome et de Firefox expérimental | Chrome, Safari, Firefox, Opera, Edge et Internet Explorer |
Performance | 60% plus rapide que le sélénium | Rapide |
Prise en charge du système d'exploitation | Windows, Linux et macOS | Windows, Linux, macOS et Solaris |
Architecture | Architecture basée sur les événements avec des instances de navigateur sans interface graphique | Protocole JSONWire sur le pilote Web pour contrôler l'instance du navigateur |
Conditions préalables | Le package JavaScript suffit | Liaisons Selenium (pour le langage de programmation sélectionné) et pilotes Web du navigateur |
Communauté | Communauté plus petite par rapport à Selenium | Une documentation bien établie et une large communauté |
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.