Puppeteer vs. Selenium: Was sollte man für Web Scraping wählen?

Versuchen Sie, sich zwischen Puppeteer und Selenium für Web Scraping zu entscheiden? Beide sind leistungsstarke Frameworks zur Browserautomatisierung, und die richtige Wahl hängt von Ihren spezifischen Scraping-Anforderungen und den verfügbaren Ressourcen ab.

Damit Sie eine fundierte Entscheidung treffen können, haben wir in der folgenden Tabelle die wichtigsten Unterschiede zwischen Puppeteer und Selenium hervorgehoben. Anschließend gehen wir auf die Details ein und stellen für jedes Framework ein Scraping-Beispiel bereit, um ihre Wirksamkeit beim Extrahieren von Daten aus Webseiten zu demonstrieren.

Lassen Sie uns diese Bibliotheken nun im Detail besprechen und mit jeder ein Scraping-Beispiel durchführen, um ihre Effizienz beim Extrahieren von Daten aus einer Webseite zu veranschaulichen.

Puppenspieler

Puppenspieler ist eine Node.js-Bibliothek, die eine High-Level-API zur Steuerung von Chrome oder Chromium über das DevTools-Protokoll bereitstellt. Sie ist für die Automatisierung von Aufgaben in Chrome oder Chromium konzipiert, wie z. B. das Erstellen von Screenshots, das Generieren von PDFs und das Navigieren auf Seiten.

Puppeteer kann auch zum Testen von Webseiten verwendet werden, indem Benutzerinteraktionen wie das Klicken auf Schaltflächen, das Ausfüllen von Formularen und das Überprüfen der angezeigten Ergebnisse simuliert werden.

Vorteile von Puppeteer

• Benutzerfreundlichkeit: Einfach und unkompliziert zu verwenden.
• Im Lieferumfang von Chromium enthalten: Es ist keine zusätzliche Einrichtung erforderlich.
• Headless-Modus: Läuft standardmäßig im Headless-Modus, kann aber so konfiguriert werden, dass es im vollständigen Browsermodus ausgeführt wird.
• Ereignisgesteuerte Architektur: Macht manuelle Sleep-Aufrufe in Ihrem Code überflüssig.
• Umfassende Funktionen: Kann Screenshots machen, PDFs erstellen und alle Browseraktionen automatisieren.
• Leistungsmanagement: Bietet Tools zum Aufzeichnen der Laufzeit und der Ladeleistung, um Ihren Scraper zu optimieren und zu debuggen.
• SPA-Crawling: Kann Single Page Applications (SPAs) crawlen und vorgerenderte Inhalte generieren (serverseitiges Rendering).
• Skriptaufzeichnung: Ermöglicht das Erstellen von Puppeteer-Skripten durch Aufzeichnen von Aktionen im Browser mithilfe der DevTools-Konsole.

Nachteile von Puppeteer

• Eingeschränkte Browserunterstützung: Unterstützt im Vergleich zu Selenium weniger Browser.
• Fokussiert auf JavaScript: Unterstützt hauptsächlich JavaScript, obwohl es inoffizielle Ports für Python und PHP gibt.

Web Scraping Beispiel mit Puppeteer

Lassen Sie uns ein Tutorial zum Web Scraping mit Puppeteer durchgehen, um Elemente aus der Kategorie „Kriminalität und Thriller“ der Danube-Website zu extrahieren.

Donau-Shop: Krimis und Thriller

Importieren Sie zunächst das Puppeteer-Modul und erstellen Sie eine asynchrone Funktion zum Ausführen des Puppeteer-Codes:

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

Erwartete Ausgabe

Wenn Sie den Code ausführen, sollte die Ausgabe etwa folgendermaßen aussehen:

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

Ein weiteres Beispiel für die Verwendung von Puppeteer

Puppeteer kann nicht nur Daten von Webseiten extrahieren, sondern auch für eine Vielzahl von Automatisierungsaufgaben verwendet werden. Ein häufiger Anwendungsfall ist die Generierung einer PDF-Datei einer Webseite. Sehen wir uns ein Beispiel an, bei dem Puppeteer zur Generierung einer PDF-Datei aus einer Webseite verwendet wird.

Erstellen einer PDF-Datei mit Puppeteer

Schritt 1: Puppeteer importieren und eine asynchrone Funktion erstellen

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

Zusätzliche Puppenspieler-Optionen

Puppeteer bietet verschiedene Optionen zum Generieren von PDFs, die an Ihre Anforderungen angepasst werden können. Hier sind einige der Optionen, die Sie verwenden können:

• path: Der Dateipfad zum Speichern der PDF-Datei.
• format: Das Papierformat (z. B. „A4“, „Letter“).
• printBackground: Ob die Hintergrundgrafiken einbezogen werden sollen.
• landscape: Einstellen true für Querformat.
• margin: Geben Sie die Ränder für das PDF an (oben, rechts, unten, links).

Beispiel mit zusätzlichen Optionen:

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

Beispielausgabe

Durch Ausführen des obigen Codes wird eine PDF-Datei mit dem Namen erstellt example.pdf im aktuellen Verzeichnis mit dem Inhalt der Webseite https://example.com.

Puppeteer ist ein vielseitiges Tool für Webautomatisierungsaufgaben, vom Scraping von Daten bis zum Generieren von PDFs. Seine Benutzerfreundlichkeit und seine leistungsstarken Funktionen machen es zu einer hervorragenden Wahl für die Automatisierung einer Vielzahl von Browseraktivitäten. Egal, ob Sie Daten scrapen, Berichte erstellen oder Webseiten testen, Puppeteer bietet die Tools, die Sie benötigen, um die Arbeit effizient zu erledigen.

Selen

Selen ist ein Open-Source-Tool für End-to-End-Tests und Webautomatisierung, das häufig für Web Scraping verwendet wird. Zu seinen Hauptkomponenten gehören Selenium IDE, Selenium WebDriver und Selenium Grid.

• Selenium IDE: Wird verwendet, um Aktionen aufzuzeichnen, bevor sie automatisiert werden.
• Selenium WebDriver: Führt Befehle im Browser aus.
• Selenium-Gitter: Aktiviert die parallele Ausführung.

Vorteile von Selen

• Benutzerfreundlichkeit: Einfach und unkompliziert zu verwenden.
• Sprachunterstützung: Unterstützt verschiedene Programmiersprachen wie Python, Java, JavaScript, Ruby und C#.
• Browser-Automatisierung: Kann Browser wie Firefox, Edge, Safari und sogar benutzerdefinierte QtWebKit-Browser automatisieren.
• Skalierbarkeit: Es ist möglich, Selenium mithilfe von Cloud-Servern mit unterschiedlichen Browsereinstellungen auf Hunderte von Instanzen zu skalieren.
• Plattformübergreifend: Funktioniert unter Windows, macOS und Linux.

Nachteile von Selen

• Komplexes Setup: Selenium-Setup-Methoden können komplex sein.

Web Scraping-Beispiel mit Selenium

Wie bei Puppeteer gehen wir ein Tutorial zum Web Scraping mit Selenium durch und verwenden dabei dieselbe Zielsite. Wir extrahieren die Buchvorschauen aus der Kategorie „Kriminalität und Thriller“ der Danube-Website.

Donau-Shop: Krimis und Thriller

Schritt 1: Importieren Sie die erforderlichen Module und konfigurieren Sie Selenium

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

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

Schritt 2: Initialisieren Sie den Chrome WebDriver

driver = webdriver.Chrome(options=options)

Schritt 3: Navigieren Sie zur Zielwebsite

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

Schritt 4: Klicken Sie auf die Kategorie Krimi & Thriller und extrahieren Sie die Buchvorschauen

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

Schritt 5: Definieren Sie eine Funktion zum Extrahieren von Daten aus jeder Buchvorschau

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}

Schritt 6: Durchlaufen Sie die Vorschau, extrahieren Sie die Daten und beenden Sie den Treiber

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

print(extracted_data)
driver.quit()

Erwartete Ausgabe

Wenn Sie den obigen Code ausführen, wird eine Ausgabe ähnlich der folgenden erzeugt:

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

Zusätzliches Selenium-Beispiel: Einen Screenshot erstellen

Neben dem Scraping von Daten kann Selenium auch zum Erstellen von Screenshots von Webseiten verwendet werden. Hier ist ein Beispiel, wie Sie mit Selenium einen Screenshot einer Webseite erstellen.

Schritt 1: Importieren Sie die erforderlichen Module und konfigurieren Sie Selenium

from selenium import webdriver

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

Schritt 2: Initialisieren Sie den Chrome WebDriver

driver = webdriver.Chrome(options=options)

Schritt 3: Navigieren Sie zur Zielwebsite

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

Schritt 4: Machen Sie einen Screenshot

driver.save_screenshot("example_screenshot.png")

Schritt 5: Beenden Sie den Treiber

driver.quit()

Selenium ist ein vielseitiges Tool für Webautomatisierungsaufgaben, einschließlich Web Scraping und Erstellen von Screenshots. Seine Unterstützung für mehrere Programmiersprachen und Browser sowie seine Skalierbarkeit machen es zu einer leistungsstarken Wahl für verschiedene Automatisierungsanforderungen. Egal, ob Sie Daten extrahieren oder Berichte erstellen, Selenium bietet die Möglichkeit, Ihre Aufgaben effizient zu automatisieren.

Puppeteer vs. Selenium: Geschwindigkeitsvergleich

Ist Puppeteer schneller als Selenium? Die Antwort lautet ja – Puppeteer ist im Allgemeinen schneller als Selenium.

Um die Geschwindigkeit von Puppeteer und Selenium zu vergleichen, haben wir die Danube-Store-Sandbox verwendet und die oben gezeigten Skripte 20 Mal ausgeführt, wobei wir die Ausführungszeiten gemittelt haben.

Selenium-Geschwindigkeitstest

Wir nutzten die time Modul in Python, um die Ausführungszeit des Selenium-Skripts zu messen. Dabei wurde die Startzeit zu Beginn und die Endzeit am Ende des Skripts festgehalten. Die Differenz dieser Zeiten ergab die Gesamtausführungsdauer.

Hier ist das vollständige Skript, das für Selenium verwendet wird:

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

Puppenspieler-Geschwindigkeitstest

Für das Puppeteer-Skript verwendeten wir das Date Objekt zur Messung der Ausführungszeit. Dabei wurde die Startzeit zu Beginn und die Endzeit am Ende des Skripts festgehalten. Die Differenz dieser Zeiten ergab die Gesamtausführungsdauer.

Hier ist das vollständige Skript, das für Puppeteer verwendet wurde:

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

Ergebnisse des Leistungstests

Die Leistungstests zeigten, dass Puppeteer etwa 60% schneller ist als Selenium. Dieser Geschwindigkeitsvorteil macht Puppeteer zu einer geeigneteren Wahl für Projekte, die schnelles Web Scraping und Automatisierung erfordern, insbesondere bei der Arbeit mit Chromium-basierten Browsern.

Zusammenfassung der Geschwindigkeitsergebnisse:

Das folgende Diagramm veranschaulicht den Leistungsunterschied zwischen Puppeteer und Selenium:

Die Skalierung von Puppeteer-Anwendungen für Projekte, die schnelles, effizientes Web Scraping erfordern, ist in diesem Zusammenhang die optimale Wahl.

Puppeteer vs. Selenium: Was ist besser?

Welches ist also besser zum Scraping, Selenium oder Puppeteer? Auf diese Frage gibt es keine direkte Antwort, da sie von mehreren Faktoren abhängt, wie etwa langfristiger Bibliotheksunterstützung, Cross-Browser-Unterstützung und Ihren Anforderungen an das Web Scraping.

Puppeteer ist schneller, unterstützt aber im Vergleich zu Selenium weniger Browser. Selenium unterstützt im Vergleich zu Puppeteer auch mehr Programmiersprachen.

Abschluss

Obwohl Puppeteer oder Selenium eine gute Option für Web Scraping ist, kann die Skalierung und Optimierung Ihres Web Scraping-Projekts eine Herausforderung sein, da erweiterte Anti-Bot-Maßnahmen diese Bibliotheken erkennen und blockieren können. Dies lässt sich am besten durch die Verwendung einer Web Scraping-API wie OneProxy vermeiden.

Puppeteer mit Proxy-Servern verwenden

Um Puppeteer mit einem Proxy-Server zu verwenden, können Sie die Proxy-Einstellungen im args Option beim Starten der Browserinstanz. Hier ist ein Beispiel:

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

Verwenden von Selenium mit Proxyservern

Um Selenium mit einem Proxyserver zu verwenden, können Sie die Proxy-Optionen mit dem webdriver.Proxy Klasse. Hier ist ein Beispiel:

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

Die Verwendung von Proxyservern mit Puppeteer und Selenium kann dazu beitragen, IP-basierte Beschränkungen zu umgehen und das Risiko einer Blockierung zu verringern, wodurch die Effizienz Ihrer Web-Scraping-Aufgaben verbessert wird. Die rotierenden Proxys von OneProxy kann diesen Prozess weiter optimieren und ein nahtloses Scraping-Erlebnis bieten.