So verwenden Sie Pyppeteer für Web Scraping

Sind Sie bereit, die Leistungsfähigkeit der Browserautomatisierung mit Pyppeteer zu erkunden? Dann legen wir los!

TL;DR: Pyppeteer-Übersicht

Für alle, die sich ein wenig mit Web Scraping oder der Automatisierung von Aufgaben in Python auskennen, ist Pyppeteer ein großartiges Tool zum Verwalten von Webbrowsern, ohne sie sehen zu müssen (Headless-Browser).

So beginnen Sie mit Pyppeteer für das Web Scraping:

Installieren Sie Pyppeteer:

Stellen Sie zunächst sicher, dass Python und Pip installiert sind. Sie können dies überprüfen, indem Sie Folgendes ausführen: python --version Und pip --version

Verwenden Sie pip, um Pyppeteer zu installieren: pip install pyppeteer

Richten Sie Ihren Scraper ein:

Importieren pyppeteer und andere benötigte Bibliotheken wie BeautifulSoup

Schreiben Sie eine asynchrone Funktion, um einen Browser zu öffnen, eine Website aufzurufen und den Inhalt der Website abzurufen

Eine Website scrapen:

Öffnen Sie mit Pyppeteer einen Browser und rufen Sie die Website auf, die Sie scrapen möchten.

Greifen Sie auf das HTML der Seite zu und verwenden Sie BeautifulSoup, um die benötigten Daten abzurufen, wie den Seitentitel

Hier ist ein einfacher Codeausschnitt, der Pyppeteer und BeautifulSoup verwendet, um den Titel einer Seite zu extrahieren:
	import asyncio
	from pyppeteer import launch
	from bs4 import BeautifulSoup
	
	async def main():
		browser = await launch()
		page = await browser.newPage()
		await page.goto('https://books.toscrape.com/')
		html = await page.content()
		await browser.close()
	
		soup = BeautifulSoup(html, 'html.parser')
		title = soup.find('h1').text
		print('Title:', title)
	
	title = asyncio.get_event_loop().run_until_complete(main())
  
Dieser Code initiiert eine Headless-Browsersitzung, navigiert zu https://books.toscrape.com/ruft den Seiteninhalt ab und extrahiert den Webseitentitel mit BeautifulSoup.

Um diesen Snippet in Ihrem Scraping-Projekt zu verwenden, aktualisieren Sie einfach die URL und die Elemente, die Sie entsprechend Ihren Scraping-Anforderungen extrahieren möchten.

Möchten Sie mehr über das Scraping mit Pyppeteer erfahren? Weiterlesen!

Inhaltsverzeichnis

Pyppeteer: Pyppeteer mit Python verwenden

So installieren Sie Pyppeteer

Die Installation von Pyppeteer ist ein unkomplizierter Vorgang, den Sie mit dem Paketmanager von Python in nur wenigen Schritten abschließen können. pip.

Befolgen Sie diese Anweisungen, um Pyppeteer auf Ihrem Computer zum Laufen zu bringen:

Stellen Sie sicher, dass Python und Pip installiert sind: Pyppeteer erfordert Python. Sie können überprüfen, ob Python und Pip installiert sind, indem Sie die folgenden Befehle in Ihrem Terminal (Linux oder macOS) oder in der Eingabeaufforderung (Windows) ausführen:

Für Python:

Für Pip:

Wenn diese Befehle keine Versionsnummern zurückgeben, müssen Sie Python installieren, was Sie hier installieren können. Stellen Sie sicher pip wird zusammen mit Python installiert.
Installieren Sie Pyppeteer: Führen Sie den folgenden Befehl aus, um Pyppeteer zu installieren:

Dieser Befehl lädt Pyppeteer und alle seine Abhängigkeiten herunter und installiert sie.

Erstellen wir nun ein Skript, das Pyppeteer mit BeautifulSoup kombiniert, um eine Webseite zu öffnen, Inhalte zu scrapen und zu analysieren.

Schritt 1: Erforderliche Bibliotheken importieren

Nach der Installation von pyppeteer importieren wir einige wichtige Bibliotheken in unser Skript. Wir werden Folgendes einbinden: asyncio zur Handhabung asynchroner Aufgaben, pyppeteer für die Browsersteuerung und BeautifulSoup von dem bs4 Paket zum Parsen von HTML-Inhalten.

	import asyncio 
	from pyppeteer import launch 
	from bs4 import BeautifulSoup

Schritt 2: Definieren Sie die asynchrone Web Scraping-Funktion

Als nächstes definieren wir eine asynchrone Funktion namens main() das wird unser Scraping übernehmen:

	async def main():
    # Start the browser and open a new page
    browser = await launch()
    page = await browser.newPage()
    await page.goto('https://books.toscrape.com/')  # Enter the URL of the website you want to scrape

    # Retrieve HTML and close the browser
    html = await page.content()
    await browser.close()

    # Use BeautifulSoup to parse HTML
    soup = BeautifulSoup(html, "html.parser")
    title = soup.find('h1').text  # Extract the text of the first

Lassen Sie uns aufschlüsseln, wie es funktioniert:

Schritt 3: Ausführen der Funktion und Drucken der Ergebnisse

Um das Ergebnis unserer Scraping-Bemühungen zu sehen, führen wir die Hauptfunktion aus mit asyncio's Ereignisschleife, die die Ausführung der asynchronen Funktionen übernimmt:

	title = asyncio.get_event_loop().run_until_complete(main())
	print('Title:', title)

Notiz: Wenn Sie Pyppeteer zum ersten Mal verwenden, muss möglicherweise Chromium (ca. 150 MB) heruntergeladen werden, falls es nicht bereits auf Ihrem System installiert ist. Diese Ersteinrichtung kann Ihr Skript leicht verzögern.

Um Chromium vorab manuell herunterzuladen und die Wartezeit beim ersten Durchlauf zu vermeiden, führen Sie diese Anweisung in Ihrer Eingabeaufforderung oder Ihrem Terminal aus:

Dieser Befehl stellt sicher, dass Chromium auf Ihrem Computer bereit ist, und erleichtert die Ausführung Ihres Skripts, wenn Sie es ausführen möchten.

Sie können es von hier aus manuell installieren, wenn bei Ihrem Chromium-Download ein Fehler auftritt, direkt mit pyppeteer.

Nach der Installation fügen Sie den Pfad zu Ihrem Chromium.exe wenn Sie den Browser folgendermaßen starten:

	browser = await launch(executablePath='/path/to/your/chromium')

Pyppeteer-Spickzettel

In diesem Abschnitt erkunden wir verschiedene Aktionen, die Sie mit Pyppeteer durchführen können, komplett mit gebrauchsfertigen Codeausschnitten, die Ihnen helfen, diese Funktionen reibungslos in Ihre Projekte zu integrieren.

So warten Sie mit Pyppeteer, bis die Seite geladen ist

Für effektives Web Scraping oder Browserautomatisierung mit Pyppeteer muss möglicherweise sichergestellt werden, dass der gesamte Seiteninhalt geladen wurde, bevor Sie fortfahren. Hier sind einige praktische Methoden, um dies zu erreichen:

1. Warten Sie eine bestimmte Zeit

Um Ihr Skript für eine bestimmte Zeit anzuhalten, verwenden Sie die page.waitFor() Funktion. Zum Beispiel das Hinzufügen page.waitFor(5000) lässt das Skript 5 Sekunden warten, bevor es fortfährt.

So verwenden Sie es:

	await page.goto('https://books.toscrape.com/')
	await page.waitFor(5000)  # Wait for 5000 milliseconds (5 seconds)

2. Warten Sie auf einen bestimmten Selektor

Eine andere Methode besteht darin, zu warten, bis ein bestimmtes Seitenelement sichtbar wird, bevor fortgefahren wird.

Dies können Sie tun, indem Sie waitForSelector() Funktion. In diesem Beispiel sagen wir dem Browser, er soll warten, bis ein Element mit dem .thumbnail Klasse erscheint, bevor irgendetwas anderes getan wird.

So können Sie es verwenden:

	await page.goto('https://books.toscrape.com/')
	await page.waitForSelector('.thumbnail')

So erstellen Sie Screenshots mit Pyppeteer

Das Aufnehmen von Screenshots ist eine leistungsstarke Funktion in Pyppeteer, die zum Debuggen, Archivieren von Snapshots von Webseiten oder Überprüfen von UI-Elementen verwendet werden kann.

Um die gesamte Seitenlänge zu erfassen, wie sie im Ansichtsfenster angezeigt wird, verwenden Sie die screenshot() Methode.

Navigieren Sie zunächst zu Ihrer Zielwebseite mit dem goto() Methode
Nachdem Sie die Seite erreicht haben, erstellen Sie einen Screenshot mit dem screenshot() Funktion und geben Sie den Dateinamen an:

	await page.goto('https://books.toscrape.com/')
	await page.screenshot({'path': 'example.png'})

Der Screenshot wird in Ihrem Projektordner gespeichert. Er erfasst den sichtbaren Bereich der Seite entsprechend den Standardeinstellungen des Ansichtsfensters.

Zeigt, wie man Screenshots in Pyppeteer macht

Um einen Screenshot mit bestimmten Abmessungen aufzunehmen, können Sie den Ansichtsbereich festlegen, bevor Sie zur Seite navigieren, indem Sie den setViewport() Methode:

	await page.setViewport({"width": 1400, "height": 1200})
	await page.goto('https://books.toscrape.com/')
	await page.screenshot({'path': 'example.png'})

Der Screenshot wird mit den von Ihnen angegebenen Abmessungen erstellt.

Screenshot mit vollständigen Abmessungen von pyppetter

Für einen Screenshot der gesamten Seite, der unabhängig vom aktuellen Ansichtsfenster vom oberen bis zum unteren Rand der Seite erfasst, setzen Sie fullPage auf true, nachdem Sie den Pfad des Bildes im screenshot() Methode:

	await page.goto('https://books.toscrape.com/')
	await page.screenshot({'path': 'example.png', 'fullPage':True})

So klicken Sie mit Pyppeteer auf Schaltflächen

Mit Pyppeteer ist das Klicken auf eine Schaltfläche oder ein anderes interaktives Element auf einer Webseite unkompliziert.

Zuerst müssen Sie das Element anhand seines Selektors identifizieren und Pyppeteer dann anweisen, darauf zu klicken. In unserem Beispiel möchten wir auf den Link zum Buch „A Light in the Attic“ auf der Website „Books to Scrape“ klicken.

Wir können das genaue Element finden und die href Attribut, das wir mithilfe der Entwicklertools identifizieren müssen.

Nachdem wir nun das Element haben, verwenden wir die click() Funktion, um darauf zu klicken und verwenden Sie die waitForSelector() Funktion, um dem Browser mitzuteilen, dass er auf das Element warten soll, bevor wir darauf klicken.

	import asyncio
	from pyppeteer import launch
	
	async def click_link():
		browser = await launch(headless=False)  # Launches a visible browser for demonstration
		page = await browser.newPage()
	
		# Navigate to the webpage
		await page.goto('https://books.toscrape.com/')
		
		# Wait for the link to be clickable and click it
		await page.waitForSelector('a(href="catalogue/a-light-in-the-attic_1000/index.html")')
		await page.click('a(href="catalogue/a-light-in-the-attic_1000/index.html")')

Nachdem Sie auf den Link geklickt haben, navigiert das Skript zur Detailseite des Buchs.

Um zu bestätigen, dass die Navigation erfolgreich war und der Klick zur richtigen Seite geführt hat, machen wir einen Screenshot der Seite.

	# Wait for the page to load fully
    await page.waitFor(10000)  # Wait for 10 seconds to ensure the page has fully loaded
    await page.setViewport({"width": 1400, "height": 1200})  # Set the dimensions for the screenshot
    await page.screenshot({'path': 'example.png'})  # Save the screenshot

    await browser.close()  # Close the browser after the screenshot

asyncio.get_event_loop().run_until_complete(click_link())

Und es hat funktioniert!

Hier ist der Screenshot gespeichert als beispiel.png. Es zeigt die Detailseite von „A Light in the Attic“ und bestätigt, dass unser Skript erfolgreich ausgeführt wurde.

Das ausgeführte Ergebnis des Screenshots von pyppeteer

So scrollen Sie mit Pyppeteer durch eine Webseite

Das automatische Scrollen durch Seiten ist unerlässlich, wenn Sie mit Websites arbeiten, deren Inhalt dynamisch geladen wird, während Sie nach unten scrollen. Pyppeteer macht dies einfach, indem es seine evaluate() Funktion, um Python-Code direkt im Browserkontext auszuführen. Hier ist ein einfaches Beispiel:

	import asyncio
	from pyppeteer import launch
	
	async def simple_scroll():
		browser = await launch(headless=False)  # Launches a browser with a visible UI
		page = await browser.newPage()
		await page.setViewport({'width': 1280, 'height': 720})  # Sets the size of the viewport
		await page.goto('https://books.toscrape.com')  # Navigate to the website
		
		# Scroll to the bottom of the page
		await page.evaluate('window.scrollBy(0, document.body.scrollHeight);')
		
		# Wait for additional content to load
		await page.waitFor(5000)
		
		await browser.close()
	
	asyncio.get_event_loop().run_until_complete(simple_scroll())

Dieses Pyppeteer-Skript navigiert zur Webseite und scrollt nach unten mit window.scrollBy()wartet einige Sekunden, um sicherzustellen, dass alle dynamischen Inhalte geladen wurden, und schließt dann den Browser.

So verwenden Sie einen Proxy mit Pyppeteer

Beim Scraping von Websites ist die Verwendung von Proxys unerlässlich, um eine Blockierung durch die Zielseiten zu vermeiden. Wenn Sie regelmäßig eine große Anzahl von Anfragen von derselben IP-Adresse senden, kann dies dazu führen, dass Ihre IP blockiert wird.

Proxys sind Vermittler zwischen Ihrem Scraper und der Website. Sie stellen Ihren Anfragen unterschiedliche IP-Adressen zur Verfügung. Dadurch werden Ihre Scraping-Aktivitäten maskiert, sodass es so aussieht, als kämen sie von mehreren Benutzern und nicht von einer einzigen Quelle.

Ressource: Wenn Sie mehr über Proxys und ihre Funktionsweise erfahren möchten, lesen Sie diesen Artikel zur Verwendung und Rotation von Proxys in Python.

Um einen Proxy mit Pyppeteer zu verwenden, können Sie ihn beim Starten des Browsers angeben.

So können Sie vorgehen und die Authentifizierung durchführen, falls Ihr Proxy dies erfordert:

	import asyncio
	from pyppeteer import launch
	
	async def use_proxy():
		browser = await launch({
			'args': ('--proxy-server=your_proxy_address:port')
		})
		page = await browser.newPage()
		await page.authenticate({'username': 'your_username', 'password': 'your_password'})
	
		await page.goto('https://books.toscrape.com')
	
		await browser.close()
	
	asyncio.get_event_loop().run_until_complete(use_proxy())

Wenn Ihr Proxy geschützt ist, verwenden Sie die authenticate() Methode, um die erforderlichen Anmeldeinformationen bereitzustellen.

So integrieren Sie ScraperAPI mit Pyppeteer

Pyppeteer bewältigt die Browserautomatisierung zwar hervorragend, verwaltet jedoch keine Proxys direkt. ScraperAPI füllt diese Lücke, indem es eine robuste Proxyverwaltung bereitstellt, die für die Umgehung von IP-basierten Blockierungen und Ratenbegrenzungen durch Zielwebsites unerlässlich ist.

Darüber hinaus kann ScraperAPI Seiten mit großem JavaScript-Aufwand rendern, wodurch die Komplexität Ihrer Skripte reduziert und die Erfolgsquote beim Scraping dynamischer Inhalte verbessert wird.

Indem Sie die Proxy-Verwaltung und das CAPTCHA-Lösen ScraperAPI überlassen, werden Ihre Scraping-Skripte einfacher und konzentrieren sich mehr auf die Datenextraktionslogik als auf die Navigation durch Anti-Scraping-Maßnahmen.

So können Sie ScraperAPI in Ihre Pyppeteer-Skripte integrieren:

Schritt 1: Einrichten Ihres Browsers mit ScraperAPI

Zuerst müssen wir Pyppeteer so konfigurieren, dass ScraperAPI als Proxy verwendet wird. Dadurch werden nicht nur unsere Verbindungen über verschiedene IPs verwaltet, sondern auch potenzielle Websicherheitsmaßnahmen behandelt, die unser Scraping blockieren oder verlangsamen könnten:

	browser = await launch({
		'ignoreHTTPSErrors': True,
		'args': ('--proxy-server=proxy-server.scraperapi.com:8001'),
	})

Dieses Proxy-Setup leitet den gesamten Browserverkehr über ScraperAPI und nutzt dessen Fähigkeit, Site-Einschränkungen und Ratenbegrenzungen zu umgehen. Wir weisen den Browser außerdem an, alle HTTPS-Fehler zu ignorieren, um Unterbrechungen aufgrund von SSL/TLS-Problemen zu vermeiden.

Hinweis: Ausführlichere Informationen finden Sie in der ScraperAPI-Dokumentation.

Schritt 2: Authentifizierung mit ScraperAPI

Authentifizieren Sie sich anschließend mit ScraperAPI, um sicherzustellen, dass Ihre Anfragen richtig erkannt und verwaltet werden:

	await page.authenticate({
		'username': 'scraperapi',
		'password': 'YOUR_SCRAPERAPI_KEY'  # Use your actual ScraperAPI key here
	})

Notiz: Benötigen Sie einen Scraper-API-Schlüssel? Erstellen Sie ein kostenloses ScraperAPI-Konto, um einen API-Schlüssel und 5.000 API-Credits zu erhalten.

Schritt 3: Navigieren Sie zu Ihrer Zielwebsite

Leiten wir nun unseren Browser zu der Website weiter, von der wir Daten extrahieren möchten:

	await page.goto(target_url)
	content = await page.content()
	print(content)

Hier ist der vollständige Code:

	import asyncio
	from pyppeteer import launch
	
	async def scrape_with_scraperapi():
		target_url = 'https://example.com'
	
		browser = await launch({
			'ignoreHTTPSErrors': True,
			'args': (
				'--proxy-server=proxy-server.scraperapi.com:8001', 
			)
		})
		
		page = await browser.newPage()
		await page.authenticate({
			'username': 'scraperapi',
			'password': 'YOUR_SCRAPERAPI_KEY'
		})
		
		await page.goto(target_url)
	
		content = await page.content()
		print(content)
	
		await browser.close()
	
	asyncio.get_event_loop().run_until_complete(scrape_with_scraperapi())

Durch die Integration von ScraperAPI in Ihre Pyppeteer-Scraping-Projekte können Sie komplexere Scraping-Aufgaben problemlos bewältigen. Es erweitert die Fähigkeiten Ihrer Skripte, indem es Proxys verwaltet und CAPTCHAs automatisch löst, sodass Sie Ihre Projekte skalieren oder datenintensivere Aufgaben bewältigen können.

Lerne weiter

Herzlichen Glückwunsch, Sie haben gerade Ihren ersten Pyppeteer-Schaber gebaut!

Mit dem, was Sie heute gelernt haben, und dem Proxy-Modus von ScraperAPI können Sie dynamische Websites in großem Umfang und mit hoher Erfolgsquote scrapen und so einen konsistenten Datenstrom erstellen.

Natürlich können Sie auch die JS-Rendering-Funktion von ScraperAPI verwenden, um die Komplexität Ihres Codes zu reduzieren. Auf diese Weise können Sie nachträglich gerenderte HTML-Seiten herunterladen und viel einfacher auf dynamische Inhalte zugreifen.

Möchten Sie mehr über Web Scraping erfahren? Besuchen Sie unseren Blog zum projektbasierten Lernen oder sehen Sie sich hier einige unserer Lieblingsprojekte an:

Bis zum nächsten Mal, viel Spaß beim Scrapen!