Aufbau einer robusten Webautomatisierung mit Selenium und Python

Automatisierung des Webs ist heute ein unverzichtbares Werkzeug in der modernen Softwareentwicklung und -prüfung. In diesem umfassenden Selenium Python-Tutorial erfahren Sie, wie Sie ein robustes Web-Automatisierungs-Framework erstellen, das in der Lage ist, reale Szenarien zu bewältigen. Wenn Sie daran interessiert sind, automatisierte Tests in Python zu implementieren oder komplexe Web-Scraping-Automatisierungslösungen zu erstellen, finden Sie in diesem Leitfaden branchenerprobte Ansätze und Best Practices für Selenium.

Grundlagen der Webautomatisierung verstehen

Webautomatisierung ist für die moderne Softwareentwicklung, das Testen und die Datenerfassung von entscheidender Bedeutung. Die Anwendungen reichen vom End-to-End-Testen von Webanwendungen bis hin zur Vereinfachung wiederkehrender Arbeitsabläufe wie Formularübermittlungen oder Web-Scraping. Während die Python-Integration von Selenium WebDriver leistungsstarke Funktionen bietet, umfasst eine robuste Webautomatisierung mehr als nur das Schreiben von Skripten zur Nachahmung von Benutzerinteraktionen. Es geht darum, Workflows und Frameworks zu entwerfen, die wartbar, anpassbar und widerstandsfähig gegenüber Änderungen an der Ziel-Webanwendung sind.

Im Folgenden sind die wichtigsten Aspekte aufgeführt, die wir in diesem Tutorial behandeln werden:

• Auswahl geeigneter Locators (XPath, CSS usw.)
• Dynamische Elemente und Zustandsladen
• Implementierung von Wiederholungsmechanismen
• Browsersitzungen richtig verwalten
• Wartbarkeitsstruktur des Codes

Wir werden ein Web-Scraping-Automatisierungsprojekt für einen Preis-Tracker auf E-Commerce-Websites erstellen und dabei Books to Scrape als Demo-Site verwenden, um diese Konzepte zu demonstrieren und dabei die Best Practices von Selenium einzuhalten.

Voraussetzungen

Um diesem Tutorial folgen zu können, benötigen Sie:

• Python 3.x ist auf Ihrem Computer installiert.
• Grundkenntnisse der Python-Programmierung
• Grundkenntnisse über Web Scrapping mit Selenium

Der Code für dieses Tutorial ist in unserem Github-Repository verfügbar. Sie können ihn gerne klonen, um mitzumachen.

Einrichten der Entwicklungsumgebung

Lassen Sie uns eine geeignete Entwicklungsumgebung einrichten und die erforderlichen Python-Pakete installieren. Erstellen Sie zunächst den Projektordner und eine neue virtuelle Umgebung, indem Sie die folgenden Befehle ausführen:

mkdir price_tracker_automation && cd price_tracker_automation
python3 -m venv env
source env/bin/activate

Erstellen Sie dann die folgenden Python-Pakete und fügen Sie sie Ihrer Datei „requirements.txt“ hinzu:

selenium==4.16.0
webdriver-manager==4.0.1
python-dotenv==1.0.0
requests==2.31.0

Im obigen Code haben wir unsere Kernabhängigkeiten definiert. Das Selenium-Paket bildet die Grundlage für unser Web-Automatisierungs-Framework, während der Webdriver-Manager die Browser-Treiberverwaltung automatisch übernimmt. Das Paket „python-dotenv“ dient der Umgebungskonfiguration und das Paket „requests“ dient der Verarbeitung von HTTP-Anfragen.

Führen Sie nun den folgenden Befehl aus, um alle Python-Pakete in Ihrer Datei „requirements.txt“ zu installieren, indem Sie den folgenden Befehl ausführen:

pip install -r requirements.txt

Zuletzt erstellen Sie die folgende Ordnerstruktur für unser Projekt:

mkdir price_tracker_automation && cd price_tracker_automation
python3 -m venv env
source env/bin/activate

Hier etablieren wir eine modulare Projektstruktur, die den Best Practices des Software-Engineerings folgt. Das Kernverzeichnis enthält unsere primären Automatisierungskomponenten, während Datenbank die Datenpersistenz übernimmt.

Aufbau des Price Tracker Tools

Nachdem wir die Projektumgebung, Abhängigkeiten und Ordnerstrukturen erstellt haben, fahren wir mit der Erstellung des Preisverfolgungs-Automatisierungstools unter Verwendung von Selenium und Python fort.

Implementierung unseres Browser-Management-Systems

Lassen Sie uns unser Browser-Verwaltungssystem implementieren. Dies ist eine wichtige Komponente für eine stabile Selenium WebDriver Python-Integration. Fügen Sie den folgenden Codeausschnitt zu Ihrer core/browser.py-Datei hinzu:

selenium==4.16.0
webdriver-manager==4.0.1
python-dotenv==1.0.0
requests==2.31.0

Der obige Code erstellt eine BrowserManager-Klasse, die die WebDriver-Initialisierung und -Konfiguration übernimmt. Die Klasse implementiert die Best Practices von Selenium, indem sie Chrome-Optionen für Stabilität und Leistung konfiguriert. Der Headless-Parameter ermöglicht die Ausführung von Tests ohne sichtbares Browserfenster, was für CI/CD-Pipelines von entscheidender Bedeutung ist.

Fügen Sie nun die folgenden Methoden zur BrowserManager-Klasse hinzu, um die Kernfunktionen der Browserverwaltung zu implementieren:

pip install -r requirements.txt

Im obigen Code verwendet die start_browser-Methode den Webdriver-Manager, um die Treiberinstallation und -aktualisierungen automatisch durchzuführen, während close_browser für die ordnungsgemäße Ressourcenbereinigung sorgt. Die Implementierung umfasst eine implizite Wartekonfiguration, um das dynamische Laden von Seiten ordnungsgemäß zu handhaben.

Erstellen eines Elementhandlers

Als nächstes implementieren wir das Elementinteraktionssystem. Dies ist in jedem Web-Automatisierungsframework wichtig, da es uns ermöglicht, Elemente auf zuverlässige Weise zu erkennen und mit ihnen zu interagieren und dabei die Best Practices von Selenium zu befolgen. Fügen Sie die Codeausschnitte zu Ihrer core/element_handler.py
hinzu

price_tracker_automation/
├── core/
│   ├── browser.py
|   ├── scraper.py
│   └── element_handler.py
├── database/
│   └── db_manager.py
├── notifications/
|   └── price_alert.py
├── requirements.txt
├── run.py
└── main.py

Im obigen Code haben wir eine ElementHandler-Klasse erstellt, die Selenium WebDriver Python-Interaktionsmuster kapselt. Die Klasse akzeptiert eine WebDriver-Instanz und einen konfigurierbaren Timeout-Parameter.

Aktualisieren Sie Ihre ElementHandler-Klasse, um Kernelement-Interaktionsmethoden hinzuzufügen:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support import expected_conditions as EC
import logging

class BrowserManager:
    def __init__(self, headless=False):
        self.options = webdriver.ChromeOptions()
        if headless:
            self.options.add_argument('--headless')

        # Add additional stability options
        self.options.add_argument('--no-sandbox')
        self.options.add_argument('--disable-dev-shm-usage')
        self.options.add_argument('--disable-gpu')

        self.driver = None
        self.logger = logging.getLogger(__name__)

Die oben genannten Methoden verwenden WebDriverWait und erwartete_Bedingungen von Selenium, um Elemente zu erkennen, sodass sie auch dynamische Webseiten verarbeiten können, bei denen die Elemente möglicherweise asynchron geladen werden.

Fügen Sie eine weitere Methode hinzu, um die Textextraktionslogik zu implementieren:

    def start_browser(self):
        """Initialize and return a ChromeDriver instance"""
        try:
 service = webdriver.ChromeService()
            self.driver = webdriver.Chrome(service=service, options=self.options)
            self.driver.implicitly_wait(10)
            return self.driver
        except Exception as e:
            self.logger.error(f"Failed to start browser: {str(e)}")
            raise

    def close_browser(self):
        """Safely close the browser"""
        if self.driver:
            self.driver.quit()
            self.driver = None

Die Methode enthält Wiederholungslogik zur Behandlung der StaleElementReferenceException, die eine häufige Herausforderung in der Webautomatisierung darstellt.

Implementierung des Price Tracker Core

Jetzt bauen wir unsere Haupt-Scraping-Funktionalität auf und integrieren automatisierte Test-Python-Konzepte und eine robuste Fehlerbehandlung. Fügen Sie die folgenden Codeausschnitte zu Ihrer core/scraper.py-Datei hinzu:

mkdir price_tracker_automation && cd price_tracker_automation
python3 -m venv env
source env/bin/activate

Im obigen Code haben wir die BookScraper-Klasse erstellt, die unsere Browser- und Elementverarbeitungskomponenten integriert. Die Klasse folgt dem Page Object Model-Muster, einem Schlüsselkonzept im Web-Automatisierungs-Framework-Design, indem sie Element-Locators zentralisiert und eine saubere API für Scraping-Vorgänge bereitstellt.

Als nächstes aktualisieren Sie die BookScraper-Klasse, um die Kernmethoden zur Produktdatenextraktion hinzuzufügen:

selenium==4.16.0
webdriver-manager==4.0.1
python-dotenv==1.0.0
requests==2.31.0

Die oben genannten Methoden verwenden einen strukturierten Ansatz zum Sammeln von Produktinformationen und führen detaillierte Protokolle zum Debuggen und Überwachen.

Einrichten der Datenbankverwaltung

Lassen Sie uns die Datenbankschicht unseres Web-Automatisierungs-Frameworks implementieren, die die dauerhafte Speicherung unserer Scraped-Daten übernimmt. Mit dieser Komponente können wir Preisänderungen im Laufe der Zeit verfolgen. Fügen Sie die folgenden Codeausschnitte zu Ihrer Datenbank/db_manager.py hinzu:

pip install -r requirements.txt

Im obigen Code haben wir unsere DatabaseManager-Klasse definiert, die alle Datenbankoperationen abwickelt. Wir haben SQLite aus Gründen der Einfachheit und Portabilität verwendet, um die Einrichtung und Konfiguration einer Datenbank zu vermeiden, und SQLite ist auch ideal für unser Web-Scraping-Automatisierungsprojekt, da wir keine großen Datenmengen speichern.

Aktualisieren Sie als Nächstes Ihre Datenbank/db_manager.py, um die Datenbankinitialisierungsmethode hinzuzufügen:

price_tracker_automation/
├── core/
│   ├── browser.py
|   ├── scraper.py
│   └── element_handler.py
├── database/
│   └── db_manager.py
├── notifications/
|   └── price_alert.py
├── requirements.txt
├── run.py
└── main.py

Hier richten wir unser Datenbankschema mithilfe von SQL-DDL-Anweisungen ein und erstellen separate Tabellen für Produkte und Preishistorie mit entsprechenden Beziehungen und Einschränkungen, die es uns ermöglichen, den Preis zu verfolgen und eine historische Analyse der von uns gespeicherten Daten durchzuführen.

Jetzt fügen wir eine weitere Methode zum Speichern von Daten in der Datenbank hinzu:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support import expected_conditions as EC
import logging

class BrowserManager:
    def __init__(self, headless=False):
        self.options = webdriver.ChromeOptions()
        if headless:
            self.options.add_argument('--headless')

        # Add additional stability options
        self.options.add_argument('--no-sandbox')
        self.options.add_argument('--disable-dev-shm-usage')
        self.options.add_argument('--disable-gpu')

        self.driver = None
        self.logger = logging.getLogger(__name__)

Im obigen Code haben wir die Datenpersistenzlogik mithilfe parametrisierter Abfragen implementiert, um SQL-Injection zu verhindern. Die Methode verarbeitet sowohl Einfüge- als auch Aktualisierungsvorgänge mithilfe der ON CONFLICT-Klausel von SQLite.

Hauptanwendungsintegration

Lassen Sie uns alles mit unserer Hauptanwendungsklasse verknüpfen und alle Elemente unserer Selenium WebDriver Python-Implementierung einbeziehen. Fügen Sie die folgenden Codeausschnitte zu Ihrer main.py-Datei hinzu:

    def start_browser(self):
        """Initialize and return a ChromeDriver instance"""
        try:
 service = webdriver.ChromeService()
            self.driver = webdriver.Chrome(service=service, options=self.options)
            self.driver.implicitly_wait(10)
            return self.driver
        except Exception as e:
            self.logger.error(f"Failed to start browser: {str(e)}")
            raise

    def close_browser(self):
        """Safely close the browser"""
        if self.driver:
            self.driver.quit()
            self.driver = None

Im obigen Code erstellen wir die Hauptklasse PriceTracker, die alle Komponenten unserer Web-Scraping-Automatisierungslösung orchestriert. Die PriceTracker-Klasse folgt Abhängigkeitsinjektionsmustern, um Modularität und Testbarkeit aufrechtzuerhalten.

Als nächstes aktualisieren Sie unsere PriceTracker-Klasse, um die wichtigsten Tracking-Methoden hinzuzufügen:

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException, StaleElementReferenceException

class ElementHandler:
    def __init__(self, driver, timeout=10):
        self.driver = driver
        self.timeout = timeout

Hier haben wir die Hauptlogik zur Produktverfolgung implementiert, die das Web-Scraping abwickelt und die Scraping-Daten speichert.

Ausführen der Anwendung

Lassen Sie uns ein Ausführungsskript erstellen, um unser Automatisierungsskript auszuführen. Fügen Sie Ihrer run.py-Datei die folgenden Codeausschnitte hinzu:

   def wait_for_element(self, locator, timeout=None):
        """Wait for element with retry mechanism"""
 timeout = timeout or self.timeout
        try:
 element = WebDriverWait(self.driver, timeout).until(
 EC.presence_of_element_located(locator)
 )
            return element
        except TimeoutException:
            raise TimeoutException(f"Element {locator} not found after {timeout} seconds")

    def get_text_safely(self, locator, timeout=None):
        """Safely get text from element with retry mechanism"""
 max_retries = 3
        for attempt in range(max_retries):
            try:
 element = self.wait_for_element(locator, timeout)
                return element.text.strip()
            except StaleElementReferenceException:
                if attempt == max_retries - 1:
                    raise
                continue

Führen Sie nun den folgenden Befehl auf Ihrem Terminal aus, um das Skript auszuführen:

mkdir price_tracker_automation && cd price_tracker_automation
python3 -m venv env
source env/bin/activate

Der obige Befehl zeigt die Ausgabe im folgenden Screenshot an:

Aus dem obigen Skript können Sie ersehen, dass unser Automatisierungsskript den Preis für alle angegebenen URLs verfolgt.

Verfolgt Preisänderungen

Unsere aktuelle Implementierung verfolgt und speichert nur Produktpreise. Nachdem wir die Preise verfolgt haben, erweitern wir unseren Preis-Tracker, um Benutzer über Preisänderungen zu informieren. Fügen Sie die folgenden Codeausschnitte zu Ihrer Datei „notifications/price_alert.py“ hinzu:

selenium==4.16.0
webdriver-manager==4.0.1
python-dotenv==1.0.0
requests==2.31.0

Im obigen Codeausschnitt haben wir eine PriceAlertManager-Klasse mit wesentlichen Abhängigkeiten erstellt. Der Manager verwendet eine Datenbankmanagerinstanz als Parameter und richtet die Protokollierung zur Verfolgung von Alarmvorgängen ein. Die Klasse verwendet komplexe Verknüpfungen, um aktuelle und frühere Preise zu vergleichen. Anschließend haben wir eine dynamische Berechnung des Preisänderungsprozentsatzes implementiert und ein strukturiertes Wörterbuch für Preisänderungsinformationen erstellt.

Aktualisieren Sie als Nächstes Ihre PriceAlertManager-Klasse, um eine E-Mail-Benachrichtigungsfunktion hinzuzufügen:

pip install -r requirements.txt

Hier haben wir eine E-Mail-Benachrichtigung mit den E-Mail- und SMTP-Bibliotheken von Python erstellt. Die Implementierung verwendet die MIMEText-Klasse, um ordnungsgemäß formatierte E-Mail-Nachrichten zu erstellen. Der E-Mail-Text wird dynamisch mithilfe von F-Strings generiert und enthält detaillierte Preisänderungsinformationen mit präziser Währungsformatierung.

Jetzt ändern wir unser Ausführungsskript so, dass es Preisbenachrichtigungen enthält:

price_tracker_automation/
├── core/
│   ├── browser.py
|   ├── scraper.py
│   └── element_handler.py
├── database/
│   └── db_manager.py
├── notifications/
|   └── price_alert.py
├── requirements.txt
├── run.py
└── main.py

Wenn Sie das Skript nun erneut ausführen, verfolgt es die Produktpreise und benachrichtigt Sie über die Produkte, deren Preise sich geändert haben, wie im Screenshot unten:

Vielleicht können Sie dieses Skript in einem Cron-Job ausführen, um die Produktpreise zu verfolgen und Sie in Echtzeit über Preisänderungen zu informieren, ohne es jedes Mal manuell ausführen zu müssen.
Z.B. 0 */6 * * * python run.py --urls
„http://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html“
„http://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html“
„http://books.toscrape.com/catalogue/soumission_998/index.html“

Abschluss

In diesem Tutorial haben Sie gelernt, wie Sie mit Selenium und Python ein robustes Web-Automatisierungstool erstellen. Wir begannen damit, die Grundlagen der Webautomatisierung zu verstehen, und richteten dann eine Entwicklungsumgebung für das Price Traker-Tool ein, das wir für die Demonstrationen in diesem Tutorial erstellt hatten. Anschließend haben wir die Preisverfolgungsanwendung entwickelt, die die Preise von Produkten verfolgt und Benutzer über Preisänderungen informiert. Da Sie nun über dieses Wissen verfügen, fragen Sie sich, welches Tool Sie als Nächstes entwickeln würden. Lass es mich im Kommentarbereich wissen. Viel Spaß beim Codieren!

Das obige ist der detaillierte Inhalt vonAufbau einer robusten Webautomatisierung mit Selenium und Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!