Kopfloser Browser in Python

Headless-Browser sind eine entscheidende Komponente sowohl beim Web Scraping als auch beim automatisierten Testen. Sie führen alle üblichen Browseroperationen aus, wie das Laden von Webseiten, die Ausführung von JavaScript und die Interaktion mit dem DOM (Document Object Model), jedoch ohne Benutzeroberfläche.

Dadurch sind sie ressourceneffizienter als herkömmliche Browser und verbrauchen weniger Speicher und CPU-Zeit. Darüber hinaus können Vorgänge im Headless-Modus schneller sein, da keine Verarbeitung und kein Rendern von Grafiken erforderlich ist.

In diesem Artikel werden wir die Vorteile der Verwendung von Headless-Browsern in Python untersuchen. Wir bieten außerdem einen Überblick über beliebte Headless-Browserbibliotheken, darunter Selenium, Pyppeteer und andere. Wir besprechen die wichtigsten Funktionen und Fähigkeiten jeder Bibliothek und geben Ihnen Hinweise zur Auswahl der richtigen Bibliothek für Ihre spezifischen Anforderungen.

Auswahl eines Headless-Browsers für Python

Die Auswahl eines Headless-Browsers für Python ist entscheidend für die Entwicklung von Programmen, die mit Webseiten interagieren, ohne ein Browserfenster zu öffnen. Betrachten wir zunächst, welche Headless-Browser wir in Python verwenden können, welche Bibliotheken sie bereitstellen, und vergleichen ihre Fähigkeiten und zu berücksichtigenden Faktoren.

Beliebte Headless-Browser für Python

Python verfügt über mehrere Bibliotheken, die die Arbeit mit Headless-Browsern ermöglichen. Die beliebtesten sind jedoch die folgenden:

1. Selen. Dies ist eines der beliebtesten Tools zur Webbrowser-Automatisierung. Damit können Sie verschiedene Browser, einschließlich Chrome und Firefox, im Headless-Modus steuern. Es verfügt über umfangreiche Funktionalität und eine aktive Benutzergemeinschaft.
2. Pyppeteer. Dies ist ein Python-Wrapper für die bekannte Puppeteer-Bibliothek, der ursprünglich für NodeJS entwickelt wurde und zur Automatisierung der Chrome- und Chromium-Browser entwickelt wurde. Pyppeteer bietet eine einfache und praktische Schnittstelle zur Steuerung des Browsers im Headless-Modus, einschließlich der Möglichkeit, mit dem DOM zu interagieren und JavaScript auszuführen.
3. Dramatiker ist im Vergleich zu früheren von Microsoft entwickelten Tools ein relativ neues Tool. Es unterstützt die Automatisierung von Chrome-, Firefox- und WebKit-Browsern im Headless- und regulären Modus. Playwright bietet umfangreiche Funktionen zum Testen und Web-Scraping und unterstützt auch die asynchrone Ausführung von Vorgängen.
4. Mechanische Suppe. Im Gegensatz zu anderen Tools bietet es nicht direkt einen Headless-Modus, sondern kann Web Scraping durchführen, ohne einen Browser anzuzeigen.

Neben den oben genannten Bibliotheken gibt es noch weitere, beispielsweise Ghost.py. Allerdings sind diese Bibliotheken weniger beliebt, haben weniger aktive Communities und bieten einen geringeren Funktionsumfang. Einige Leute halten Scrapy auch für eine Web-Scraping-Bibliothek mit einem Headless-Browser, sie eignet sich jedoch besser zum Crawlen von Webseiten und ermöglicht keine Steuerung eines Browsers.

Vergleich verschiedener Headless-Browser

Um diese Bibliotheken besser vergleichen zu können, erstellen wir eine Tabelle, die einen klaren und prägnanten Überblick über ihre Fähigkeiten bietet:

Nach unserer Erfahrung sind Selenium und Pyppeteer die besten Bibliotheken für die Arbeit mit Headless-Browsern.

Wenn Sie mit mehreren Browsern arbeiten müssen und mit Web Scraping noch nicht vertraut sind, empfehlen wir, mit Selenium zu beginnen. Es ist relativ einfach zu erlernen und bietet viele Module zum Parsen von Daten, wie in unserem Tutorial zum Scraping mit Selenium WebDriver besprochen.

Wenn Sie nur mit Headless-Chrome- oder Chromium-Browsern arbeiten möchten, asynchrone Aufgaben bevorzugen oder Erfahrung mit Node.js haben, ist Pyppeteer möglicherweise die bessere Wahl. Auch Web Scraping mit Pyppeteer haben wir bereits in einem anderen Artikel behandelt.

Bibliotheken, die nach Selenium und Pyppeteer entwickelt wurden, verfügen häufig über ähnliche Funktionen oder es fehlen möglicherweise einige Funktionen. Darüber hinaus verfügen Selenium und Pyppeteer über Varianten für die meisten modernen Programmiersprachen, was zu größeren Communities, besserer Dokumentation und aktiver Entwicklung führt.

Erste Schritte mit einem Headless-Browser in Python

Wie bereits erwähnt, sind Selenium und Pyppeteer zwei hervorragende Bibliotheken für die Arbeit mit Headless-Browsern. Obwohl wir für jedes einzelne einen eigenen Artikel haben, gibt dieser Abschnitt einen kurzen Überblick über die Installation und die grundlegenden Skriptfunktionen zum Starten und Abrufen des HTML-Codes einer Seite. Wir hoffen, dass dieser Vergleich Ihnen bei der Auswahl der besten Bibliothek hilft.

Installieren eines Headless-Browsers in Python

Jede Bibliothek hat ihre eigenen Installationsspezifikationen. Betrachten wir sie daher der Reihe nach, beginnend mit Pyppeteer. Da für den Betrieb Puppeteer verwendet wird, müssen Sie NodeJS installieren, um es verwenden zu können. Öffnen Sie dann das Terminal und führen Sie den folgenden Befehl aus, um Pyppeteer über pip zu installieren:

pip install pyppeteer

Während der Installation versucht Pyppeteer, Chromium für den Betrieb herunterzuladen. Sie können jedoch einen anderen Browser auswählen, indem Sie dessen Pfad im angeben PYPPETEER_EXECUTABLE_PATH Umgebungsvariable.

Um Selenium zu installieren, öffnen Sie das Terminal und verwenden Sie den folgenden Befehl:

pip install selenium

Sie benötigen außerdem einen Webtreiber für den von Ihnen gewählten Browser, um mit früheren Selenium-Versionen arbeiten zu können. Um beispielsweise mit dem Chrome-Browser arbeiten zu können, benötigen Sie Chrome WebDriver. Stellen Sie sicher, dass sich der Treiber in Ihrem Pfad befindet, oder geben Sie den Pfad dazu im Code an. Es ist außerdem wichtig zu beachten, dass die Version des Webtreibers mit der Version des installierten Browsers übereinstimmen muss.

Schreiben Sie Ihr erstes Headless-Browser-Skript

Lassen Sie uns beispielsweise ein kleines Skript erstellen, um zu dieser Demo-Website zu navigieren und den Seitentitel abzurufen. Beginnen wir mit der Pyppeteer-Bibliothek. Erstellen Sie eine neue Datei mit der Erweiterung .py und importieren Sie die erforderlichen Bibliotheken:

import asyncio
from pyppeteer import launch

Definieren Sie eine Funktion, die einen Headless-Browser verwendet, und rufen Sie sie asynchron mithilfe der zuvor importierten Asyncio-Bibliothek auf:

async def main():
    # Here will be code

asyncio.get_event_loop().run_until_complete(main())

Lassen Sie uns die Hauptfunktion verbessern. Zuerst erstellen wir ein Headless-Browserobjekt:

    browser = await launch(headless=True)

Um eine bestimmte Browserdatei zu verwenden, müssen Sie deren Pfad angeben:

    browser = await launch(headless=True, executablePath="chrome-win/chrome.exe")

Erstellen Sie dann ein neues Browserfenster und eine neue Registerkarte:

    page = await browser.newPage()

Gehen Sie zur Seite der Demo-Website:

    await page.goto('https://demo.opencart.com/')

Extrahieren Sie den Seitentitel:

    title = await page.title()

Zeigen Sie abschließend die Ausgabe an und schließen Sie den Browser:

    print("Page title:", title)
    await browser.close()

Der gesamte Code sieht so aus:

import asyncio
from pyppeteer import launch

async def main():
    browser = await launch(headless=True, executablePath="chrome-win/chrome.exe")
    page = await browser.newPage()
    await page.goto('https://demo.opencart.com/')
    title = await page.title()
    print("Page title:", title)
    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

Lassen Sie uns das Skript ausführen und das Ergebnis beobachten:

Dasselbe erreichen wir mit der Selenium-Bibliothek. Importieren wir zunächst alle benötigten Module:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

Geben Sie den Headless-Modus an, um den Browser im Hintergrund ohne grafische Benutzeroberfläche (GUI) auszuführen:

chrome_options = Options()
chrome_options.add_argument('--headless')

Lassen Sie uns ein Headless-Browserobjekt instanziieren:

driver = webdriver.Chrome(options=chrome_options)

Diese Methode zum Erstellen eines Objekts funktioniert nur, wenn Sie die neuesten Versionen der Bibliothek verwenden. Wenn Sie jedoch eine frühere Version von Selenium haben, müssen Sie den Pfad zur Webtreiberdatei angeben:

driver = webdriver.Chrome(executable_path="C:\driver\chromedriver.exe", options=chrome_options)

Navigieren wir zur Seite der Demo-Website und extrahieren deren Inhalt:

driver.get('https://demo.opencart.com/')

Rufen Sie den Titel ab und zeigen Sie ihn an:

title = driver.title
print("Page title:", title)

Stellen Sie sicher, dass Sie am Ende den Browser schließen:

driver.quit()

Das vollständige Skript lautet wie folgt:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

chrome_options = Options()
chrome_options.add_argument('--headless')

driver = webdriver.Chrome(options=chrome_options)
driver.get('https://demo.opencart.com/')
title = driver.title
print("Page title:", title)
driver.quit()

Lassen Sie es uns ausführen und sicherstellen, dass wir dieselben Daten erhalten wie bei der Verwendung von Pyppeteer:

Wie Sie sehen, erzielten beide Ansätze das gleiche Ergebnis. Allerdings arbeitet Pyppeteer standardmäßig ausschließlich im asynchronen Modus. Daher erfordert seine Verwendung eine zusätzliche Asyncio-Bibliothek. Andererseits benötigt Selenium für seinen Betrieb keine zusätzlichen Bibliotheken.

Häufige Aufgaben mit Headless-Browsern in Python

Die betrachteten Bibliotheken verfügen über eine recht umfangreiche Funktionalität, mit der Sie die meisten Aufgaben lösen können, für die ein Headless-Browser benötigt wird. Betrachten wir einige davon:

1. Daten-Scraping. Wie wir im Beispiel gezeigt haben, können Sie mit Headless-Browsern die Datenerfassung von Webseiten automatisieren. Dies kann nützlich sein, um Informationen zur Analyse, Nachrichtenaggregation oder Preisüberwachung zu extrahieren.
2. Testen von Webanwendungen. Headless-Browser werden auch häufig für automatisierte Browsertests von Webanwendungen verwendet, da Sie damit das Verhalten echter Benutzer nachahmen können.
3. Screenshots machen. Headless-Browser können nützlich sein, wenn Sie nicht viele Screenshots manuell erstellen möchten.

Dies sind nur einige der häufigsten Aufgaben, die mit Headless-Browsern in Python ausgeführt werden können. Tatsächlich können sie überall dort nützlich sein, wo viele monotone Aktionen im Browser erforderlich sind. Darüber hinaus nehmen Websites ein solches Skript aufgrund des Aufrufs des Browsers nicht als Bot, sondern als echten Benutzer wahr.

Tipps und Tricks für die Headless-Browser-Entwicklung

Um die Verwendung von Headless-Browsern noch nützlicher und weiter verbreitet zu machen, werden wir einige wichtige Punkte vorstellen, die Ihnen helfen können, wie z. B. die Verwendung von Multithreading, Proxys oder benutzerdefinierten Profilen in Headless. Dadurch werden Ihre Skripte nützlicher und funktionaler.

Multithreading

Mit Multithreading können Sie mehrere Aufgaben gleichzeitig in separaten Threads ausführen. Im Zusammenhang mit Headless-Browsern kann dies nützlich sein, wenn Sie mehrere unabhängige Aktionen oder Aufgaben auf verschiedenen Webseiten gleichzeitig ausführen müssen. Beispielsweise können Sie Multithreading nutzen, um mehrere Browser aufzurufen oder mehrere Data-Scraping-Skripte parallel auszuführen, um die Leistung zu verbessern.

Pyppeteer unterstützt Multithreading nicht direkt, da sein Code von Natur aus asynchron ist und parallel ausgeführt werden kann. Allerdings ist die Verwendung von Multithreading eine großartige Option für Selenium, wenn Sie mehrere Aufgaben gleichzeitig ausführen möchten.

Lassen Sie uns beispielsweise das Skript leicht modifizieren, um mithilfe von Multithreading den Titel der Demo-Site und example.com abzurufen. Importieren wir zunächst alle notwendigen Bibliotheken und Module:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import threading

Erstellen Sie eine Variable zum Speichern einer Liste von Websites:

urls = ('https://www.example.com', 'https://demo.opencart.com/')

Verschieben Sie die vorherige Version des Skripts in eine Funktion, die die URL als Argument erhält:

def run_browser(url):
    chrome_options = Options()
    chrome_options.add_argument('--headless')

    driver = webdriver.Chrome(options=chrome_options)
    driver.get(url)
    title = driver.title
    print("Page title:", title)
    driver.quit()

Erstellen Sie eine Variable zum Speichern von Threads:

threads = ()

Threads erstellen und starten:

for url in urls:
    thread = threading.Thread(target=run_browser, args=(url,))
    threads.append(thread)
    thread.start()

Jetzt müssen wir nur noch warten, bis die Threads fertig sind:

for thread in threads:
    thread.join()

Dieser Code wartet auf den Abschluss aller gestarteten Threads, bevor er mit der Ausführung des Hauptthreads des Programms fortfährt.

Wenn Threads erstellt und gestartet werden, werden sie gleichzeitig mit dem Hauptthread des Programms ausgeführt. Um sicherzustellen, dass der Hauptthread nicht beendet wird, bevor alle erstellten Threads abgeschlossen sind, wird der join() Methode verwendet wird.

Asynchronität

Asynchronität ermöglicht die Ausführung von Vorgängen, ohne den Thread zu blockieren. Dies ist besonders nützlich für Aufgaben, bei denen auf lang laufende Vorgänge gewartet werden muss, z. B. das Laden von Webseiten oder die Ausführung von JavaScript.

Bei der Arbeit mit Headless-Browsern wird Asynchronität häufig für Vorgänge verwendet, die einige Zeit in Anspruch nehmen können, z. B. das Warten auf das Laden einer Seite oder das Senden asynchroner Anforderungen an den Server.

Im Gegensatz zu Multithreading ist Pyppeteer dagegen perfekt für den Einsatz geeignet und Selenium verfügt nicht über eine integrierte Unterstützung für Asynchronität.

Um mithilfe der Asynchronität mit dem Scraping von Daten von mehreren Seiten gleichzeitig zu beginnen, müssen wir unser vorheriges Skript, in dem wir die Arbeit von Pyppeteer demonstriert haben, nur geringfügig ändern:

import asyncio
from pyppeteer import launch

urls = ('https://www.example.com', 'https://demo.opencart.com/')

async def run_browser(url):
    browser = await launch(headless=True, executablePath="chrome-win/chrome.exe")
    page = await browser.newPage()
    await page.goto(url)
    print(await page.title())
    await browser.close()

async def main():
    tasks = (run_browser(url) for url in urls)
    await asyncio.gather(*tasks)

asyncio.run(main())

Wir haben eine Variable zum Speichern von URLs eingeführt und die Erstellung und den Start asynchroner Aufgaben implementiert. Ansonsten bleibt das Skript gleich.

Proxy-Nutzung

Mit Proxyservern können Sie Ihre echte IP-Adresse verbergen. Dies kann aus verschiedenen Gründen nützlich sein, beispielsweise um Ihren Standort zu verbergen oder Website-Sperren zu umgehen. Darüber hinaus blockieren einige Websites möglicherweise IP-Adressen, die übermäßige Anfragen stellen. Durch die Verwendung eines Proxys werden Anfragen auf verschiedene IP-Adressen verteilt, wodurch das Risiko einer Blockierung verringert wird.

Wir haben zuvor die Grundlagen von Proxys behandelt, einschließlich ihres Zwecks und wo man kostenlose Proxys und zuverlässige Proxy-Anbieter findet. Daher wird dieser Artikel nicht auf diese Themen eingehen. Stattdessen konzentrieren wir uns auf die Verwendung von Proxys mit Headless-Browsern.

Um die Proxy-Nutzung in einen Selenium-Headless-Browser zu integrieren, müssen Sie vor dem Erstellen des Objekts einen zusätzlichen Parameter hinzufügen:

proxy = 'proxy_ip:proxy_port'
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--proxy-server=%s' % proxy)

Um Pyppeteer zu verwenden, müssen Sie dasselbe tun:

proxy = 'proxy_ip:proxy_port'
browser = await launch(args=(f'--proxy-server={proxy}'), headless=True)

Wenn Sie einen Proxy verwenden und einen Benutzernamen und ein Passwort angeben möchten, sollte der Variableninhalt das folgende Format haben:

proxy = 'username:password@proxy_ip:proxy_port'

Headless-Browser unterstützen alle Proxys, einschließlich HTTP, HTTPS und SOCKS.

Benutzer-Agent-Verwaltung

Die Verwendung des Benutzeragenten ist auch für die Arbeit mit Headless-Browsern von entscheidender Bedeutung. Damit können Sie einen bestimmten Browser und ein bestimmtes Betriebssystem auf dem Webserver imitieren. Dies ist nützlich, um das Benutzerverhalten nachzuahmen und zu vermeiden, als Bot erkannt zu werden.

Darüber hinaus stellen einige Webserver je nach Benutzeragent möglicherweise unterschiedliche Versionen von Inhalten bereit. Sie können diese Funktion nutzen, um optimierte oder mobile Versionen von Webseiten herunterzuladen.

Wir haben das Konzept der Benutzeragenten zuvor ausführlich behandelt, einschließlich ihres Zwecks und einer Tabelle mit automatisch aktualisierten neuesten Benutzeragenten. Lassen Sie uns nun untersuchen, wie Sie sie mit Headless-Browsern nutzen können. Sie können den folgenden Code verwenden, um sie in Selenium zu importieren:

options = webdriver.ChromeOptions()
options.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36")

Für Pyppeteer:

browser = await launch(args=('--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36'))

Ersetzen Sie vor der Verwendung den User Agent im Beispiel durch den neuesten.

Benutzerprofil

Mit Selenium und Pyppeteer können Sie Benutzerprofile verwenden, um Ihre Browsereinstellungen wie Lesezeichen, Browserverlauf, Sicherheitseinstellungen usw. anzupassen. Um sie zu verwenden, geben Sie in Ihren Optionen den Pfad zum gewünschten Profil an.

Der Profilordner befindet sich normalerweise im Ordner des Benutzers, im Ordner „AppData“ für Windows oder im Home-Verzeichnis für macOS und Linux. Sie können den Pfad zum Profil jedoch auf der Einstellungsseite des Browsers einsehen. Um es zu öffnen, geben Sie Folgendes in die Adressleiste des Browsers ein:

1. Google Chrome: chrome://version/
2. Mozilla Firefox: about:support
3. Microsoft Edge: edge://version/

Suchen Sie nach einem Feld mit der Bezeichnung „Profilpfad“ oder „Profilordner“, das den Pfad zum Profilordner enthält. Sie können den Ordner auch kopieren und bei Bedarf auf ein anderes Gerät übertragen.

Um ein bestimmtes Profil in Selenium zu verwenden, verwenden Sie den folgenden Code:

profile_path = r'C:\Users\Admin\AppData\Local\Google\Chrome\User Data\Profile 1'
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument(f'--user-data-dir={profile_path}')

Pyppeteer bietet eine ähnliche Möglichkeit, Benutzerprofile zu verwenden. Dazu müssen Sie die Option userDataDir an die Methode launch() übergeben:

profile_path = r'C:\Users\Admin\AppData\Local\Google\Chrome\User Data\Profile 1'
browser = await launch(userDataDir=profile_path)

Stellen Sie sicher, dass Sie den Profilpfad auf Ihren aktuellen aktualisieren, bevor Sie ihn verwenden.

Verwenden von Erweiterungen

Erweiterungen können die Browserfunktionalität verbessern, indem sie zusätzliche Funktionen oder Tools hinzufügen. Dies kann für Aufgaben wie das Lösen von Captchas oder das Blockieren von Werbung nützlich sein.

Sie benötigen die Erweiterungsdatei in *.zip oder *.crx Format zur Verwendung von Erweiterungen in Headless-Browsern. Sie müssen es auch in den Browserobjektparametern angeben. In Selenium könnte dies beispielsweise so aussehen:

extension_path="folder/extension.crx"

chrome_options = webdriver.ChromeOptions()
chrome_options.add_extension(extension_path)

Für Pyppeteer:

extension_path="folder/extension.crx"

browser = await launch(headless=False, args=(f'--disable-extensions-except={extension_path}', f'--load-extension={extension_path}'))

Der --disable-extensions-except Mit der Option in Pyppeteer können Sie angeben, welche Erweiterungen außer der von Ihnen angegebenen deaktiviert werden sollen.

Fazit und Erkenntnisse

In diesem Artikel wurden die zahlreichen Vorteile der Verwendung von Headless-Browsern in Python für Web Scraping und Automatisierung untersucht. Das Starten eines Browsers im Headless-Modus bietet eine effektive Lösung für Aufgaben wie Data Scraping und Webanwendungstests und kann den Entwicklungsprozess erheblich vereinfachen.

Wir haben verschiedene Bibliotheken untersucht und sind zu dem Schluss gekommen, dass Pyppeteer und Selenium die funktionalsten sind und einen kopflosen Browserbetrieb in Python ermöglichen. Darüber hinaus haben wir wichtige Techniken und Anwendungsfälle besprochen, darunter Installation, Skripterstellung und erweiterte Funktionen wie Multithreading und Proxy-Verwaltung.

Wenn Sie Web Scraping jedoch schnell durchführen müssen und die Infrastruktur nicht selbst konfigurieren und warten möchten, können Sie auf vorgefertigte Lösungen wie unsere Web Scraping API zurückgreifen, die Ihnen sofort vorgefertigte Daten liefert. In diesem Fall müssen Sie sich nicht um die Anbindung von Proxys, das Lösen von Captchas oder die Verwendung eines Headless-Browsers zum Abrufen dynamischer Inhalte kümmern und können sich voll und ganz auf die Verarbeitung der empfangenen Daten konzentrieren.

Unabhängig davon, ob Sie sich für die Verwendung von Headless-Browsern oder einer vorgefertigten API entscheiden, ist es entscheidend, das für Ihre Anforderungen und Ziele geeignete Tool auszuwählen. Beide Ansätze bieten einzigartige Vorteile und können in verschiedenen Webentwicklungs- und Datenanalyseszenarien erfolgreich eingesetzt werden.