Amazon Produktdatenerfassung mit Python

Der Zugriff auf Daten von E-Commerce-Giganten wie Amazon ist für Marktanalysen, Preisstrategien und Produktforschung unerlässlich. Diese Daten können durch Web Scraping gesammelt werden, eine Methode, bei der große Mengen an Informationen von Websites extrahiert werden. Amazon schützt seine Daten jedoch streng, so dass herkömmliche Scraping-Techniken oft unwirksam sind. In diesem umfassenden Leitfaden befassen wir uns mit den Methoden zum Sammeln von Produktdaten von Amazon und diskutieren Strategien zur Umgehung der robusten Anti-Scraping-Systeme der Plattform. Wir erforschen die Verwendung von Python, Proxys und fortgeschrittenen Scraping-Techniken, die helfen können, diese Herausforderungen zu überwinden und effizient die Daten zu sammeln, die Sie für Ihr Geschäft oder Ihre Forschungszwecke benötigen.

Erstellung eines Python-Skripts zum Scrapen von Amazon-Daten

Um erfolgreich Daten von Amazon zu scrapen, können Sie dem unten beschriebenen strukturierten Algorithmus folgen. Diese Methode stellt sicher, dass Sie die benötigten Informationen effizient und genau abrufen können.

Schritt 1: Senden von HTTP-Anfragen an Amazon-Produktseiten:

• Nutzen Sie die Anforderungsbibliothek, um HTTP-GET-Anforderungen für Amazon-Produktseiten zu initiieren;
• Erfassen Sie den rohen HTML-Inhalt aus der HTTP-Antwort, um ihn für das Parsing vorzubereiten.

Schritt 2: Parsen des HTML-Inhalts:

• Benutzen Sie die lxml-Bibliothek, um den empfangenen rohen HTML-Inhalt zu analysieren;
• Analysieren Sie das HTML, um die spezifischen Datenpunkte zu finden, die Sie extrahieren möchten;
• Ausführen von XPath-Abfragen, um diese Datenpunkte aus der HTML-Struktur genau zu bestimmen und zu extrahieren.

Schritt 3: Speichern der Daten:

• Nach dem Extrahieren der erforderlichen Daten, speichern Sie diese in zugänglichen Formaten wie CSV oder JSON, die eine einfache Analyse und Integration in andere Anwendungen ermöglichen.

Umgang mit möglichen Hindernissen

Amazon ergreift mehrere Maßnahmen, um Scraping-Bemühungen zu verhindern, darunter Beschränkungen der Verbindungsgeschwindigkeit, CAPTCHA-Integration und IP-Blockierung. Benutzer können Gegenmaßnahmen ergreifen, um diese Hindernisse zu umgehen, wie z. B. die Verwendung von hochwertigen Proxys.

Bei umfangreichen Scraping-Aktivitäten können fortgeschrittene Python-Techniken eingesetzt werden, um große Mengen von Produktdaten zu sammeln. Zu diesen Techniken gehören Header Stuffing und TLS Fingerprinting, die dabei helfen, die Entdeckung zu umgehen und eine erfolgreiche Datenextraktion zu gewährleisten.

Diese Schritte werden in den folgenden Abschnitten des Artikels erläutert, in denen die praktische Umsetzung mit Python 3.12.2 gezeigt wird.

Voraussetzungen

Um ein Web-Scraping-Projekt zu starten, werden wir zunächst einen einfachen Scraper einrichten, der die lxml-Bibliothek für das HTML-Parsing und die requests-Bibliothek für die Verwaltung der an den Amazon-Webserver gerichteten HTTP-Anfragen verwendet.

Wir werden uns darauf konzentrieren, wesentliche Informationen wie Produktnamen, Preise und Bewertungen von Amazon-Produktseiten zu extrahieren. Wir werden auch Techniken zum effizienten Parsen von HTML und zur Verwaltung von Anfragen vorstellen, um eine präzise und organisierte Extraktion von Daten zu gewährleisten.

Um Projektabhängigkeiten aufrechtzuerhalten und Konflikte zu vermeiden, ist es ratsam, eine separate virtuelle Umgebung für dieses Web-Scraping-Vorhaben zu erstellen. Die Verwendung von Tools wie "venv" oder "pyenv" wird für die Einrichtung von virtuellen Umgebungen empfohlen.

Bibliotheken von Drittanbietern installieren

Sie benötigen die folgenden Python-Bibliotheken von Drittanbietern:

1. requests

Wird verwendet, um HTTP-Anfragen zu senden und Webinhalte abzurufen. Es wird oft für Web Scraping und die Interaktion mit Web APIs verwendet.

Installation:

 pip install requests

2. lxml

Eine Bibliothek zum Parsen und Manipulieren von XML- und HTML-Dokumenten. Sie wird häufig für Web Scraping und die Arbeit mit strukturierten Daten von Webseiten verwendet.

Installation:

 pip install lxml

Importieren der erforderlichen Bibliotheken

Hier müssen wir die erforderlichen Bibliotheken importieren, damit unser Scraper läuft. Dazu gehören die Request-Bibliothek für die Bearbeitung von HTTP-Anfragen, die CSV-Bibliothek für die Bearbeitung von CSV-Dateien, die Random-Bibliothek für die Erzeugung von Zufallswerten und Zufallsauswahlen, die lxml-Bibliothek für das Parsen des rohen HTML-Inhalts sowie Dict und List für Type Hinting.

 import requests
import csv
import random
from lxml import html
from typing import Dict, List

Lesen von Eingaben aus der CSV-Datei

Das folgende Code-Snippet liest eine CSV-Datei namens amazon_product_urls.csv, in der jede Zeile die URL einer Amazon-Produktseite enthält. Der Code iteriert über die Zeilen, extrahiert die URLs aus jeder Zeile und hängt sie an eine Liste namens URL an.

 with open('amazon_product_urls.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row in reader:
        urls.append(row['url'])

HTTP-Anfrage-Header und Proxys

Anfrage-Header spielen eine wichtige Rolle bei HTTP-Anfragen, da sie komplexe Client- und Anfrage-Informationen liefern. Beim Scraping ist es wichtig, die autorisierten Benutzertitel zu kopieren, um eine Entdeckung zu vermeiden und leicht an die gewünschten Informationen zu gelangen. Durch die Nachahmung häufig verwendeter Header können Scraper Erkennungstechniken vermeiden und sicherstellen, dass die Daten konsistent extrahiert werden, ohne dass ethische Standards verletzt werden.

Proxys fungieren beim Web-Scraping als Vermittler, die die IP-Adresse des Scrapers maskieren, um die Erkennung und Blockierung durch den Server zu verhindern. Ein rotierender Proxy ermöglicht es Ihnen, jede Anfrage mit einer neuen IP-Adresse zu senden, um mögliche Blockierungen zu vermeiden. Die Verwendung von Proxys für den privaten oder mobilen Gebrauch stärkt die Widerstandsfähigkeit gegen Anti-Scraping-Maßnahmen, da der echte Host und der Provider erkannt werden.

Code zur Einbindung von Request-Headern und Proxy-Servern mit IP-Adressautorisierung:

 headers = {
    'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
    'accept-language': 'en-IN,en;q=0.9',
    'dnt': '1',
    'sec-ch-ua': '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'sec-fetch-dest': 'document',
    'sec-fetch-mode': 'navigate',
    'sec-fetch-site': 'same-origin',
    'sec-fetch-user': '?1',
    'upgrade-insecure-requests': '1',
   }
proxies = {'http': '', 'https': ''}

Drehung der Benutzeragenturen

Hier wird eine Liste von User-Agent-Sammlungen erstellt, aus der für jede Anfrage ein zufälliger User-Agent ausgewählt wird. Die Implementierung eines Mechanismus zur Header-Rotation, z. B. die Rotation des User-Agents nach jeder Anfrage, kann dazu beitragen, Maßnahmen zur Bot-Erkennung zu umgehen.

 useragents = [
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4591.54 Safari/537.36",
        "Mozilla/5.0 (Windows NT 7_0_2; Win64; x64) AppleWebKit/541.38 (KHTML, like Gecko) Chrome/105.0.1585 Safari/537.36",
        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.7863.44 Safari/537.36"
    ]
headers['user-agent'] = random.choice(useragnets)

HTTP-Anfragen an Amazons Produktseite mit Header und Proxy stellen

Sendet eine HTTP-GET-Anfrage an eine angegebene URL mit benutzerdefinierten Headern, einem Timeout von 30 Sekunden und für die Anfrage angegebenen Proxys.

response = requests.get(url=url, headers=headers, proxies=proxies, timeout=30)

Identifizierung von XPath/Selektoren der benötigten Datenpunkte

Erforderliche Datenpunkte: Titel, Preis und Bewertungen. Lassen Sie uns nun den entsprechenden XPath für die in den Screenshots gezeigten Elemente zusammen mit den jeweiligen Datenpunkten untersuchen und identifizieren.

Der folgende Screenshot zeigt, wie die Chrome DevTools-Funktion "Inspect" verwendet wird, um den XPath `//span[@id="productTitle"]/text()` für die Extraktion des Produkttitels aus einer Amazon-Produktseite zu finden.

Der folgende Screenshot zeigt die Suche bzw. den XPath `//div[@id="corePrice_feature_div"]/div/div/span/span/text()` zum Extrahieren des Produktpreises aus einer Amazon-Produktseite.

Der Screenshot zeigt die Suche bzw. den XPath `//span[@id="acrPopover"]/@title'` zum Extrahieren der Produktbewertungen aus einer Amazon-Produktseite.

Erstellen Sie ein Wörterbuch mit XPath-Ausdrücken, um bestimmte Informationen aus einer Webseite zu extrahieren: den Titel, die Bewertungen und den Preis eines Produkts.

xpath_queries = {'title': '//span[@id="productTitle"]/text()', 'ratings': '//span[@id="acrPopover"]/@title', 'price': '//span[@class="a-offscreen"]/text()'}

Erstellen eines lxml-Parsers aus der HTML-Antwort

Der folgende Code parst den HTML-Inhalt, der aus der GET-Anfrage an den Amazon-Server stammt, in ein strukturiertes, baumartiges Format, das eine einfachere Navigation und Manipulation seiner Elemente und Attribute ermöglicht.

tree = html.fromstring(response.text)

Extrahieren der erforderlichen Daten

Das folgende Codeschnipsel extrahiert Daten aus dem geparsten HTML-Baum mit Hilfe einer XPath-Abfrage und ordnet sie einem Wörterbuch mit einem bestimmten Schlüssel zu. strip() wird verwendet, um Leerzeichen am Anfang und am Ende zu entfernen, falls vorhanden. Es ruft das erste Ergebnis der XPath-Abfrage ab und speichert es unter dem angegebenen Schlüssel im Wörterbuch "extracted_data".

data = tree.xpath(xpath_query)[0].strip()
extracted_data[key] = data

Speichern der extrahierten Daten in CSV

Der folgende Code schreibt die Daten aus dem Wörterbuch extracted_data in eine CSV-Datei namens product_data.csv. Stellen Sie sicher, dass die Kopfzeile nur geschrieben wird, wenn die Datei leer ist. Wenn die Datei nicht leer ist, werden die Daten als zusätzliche Zeile in die CSV-Datei geschrieben. Mit dieser Funktion kann die CSV-Datei kontinuierlich mit neuen extrahierten Daten aktualisiert werden, ohne dass vorhandener Text überschrieben wird.

 csv_file_path = 'product_data.csv'
fieldnames = ['title', 'ratings', 'price']
with open(csv_file_path, 'a', newline='') as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    if csvfile.tell() == 0:
        writer.writeheader()
    writer.writerow(extracted_data)

Code-Implementierung

Bitte beachten Sie unseren vollständigen Code, der Ihnen helfen wird, schnell loszulegen. Der Code ist gut strukturiert und dokumentiert, was ihn anfängerfreundlich macht. Um diesen Code auszuführen, muss der Benutzer eine CSV-Datei mit dem Namen "amazon_product_urls" im selben Verzeichnis haben. Nachfolgend ist die Struktur der CSV-Datei dargestellt:

import requests
import csv
import random
from lxml import html
from typing import Dict, List


def send_requests(
    url: str, headers: Dict[str, str], proxies: Dict[str, str]
) -> List[Dict[str, str]]:
    """
    Sendet HTTP-GET-Anfragen an mehrere URLs mit Headern und Proxys.

    Args:
        urls (str): URL, an die Anfragen zu senden sind.
        headers (Dict[str, str]): Wörterbuch mit Anforderungskopfzeilen.
        proxies (Dict[str, str]): Wörterbuch mit Proxy-Einstellungen.

    Returns:
        Response: Antwortobjekt, das die Antwortdaten für jede URL enthält.
    """
    try:
        response = requests.get(url, headers=headers, proxies=proxies, timeout=30)
        # Validierung der Antwort
        if len(response.text)> 10000:
            return response
        return None
    except Exception as e:
        print(f"Error occurred while fetching URL {url}: {str(e)}")


def extract_data_from_html(
    response, xpath_queries: Dict[str, str]
) -> Dict[str, List[str]]:
    """
    Extrahiert Daten aus HTML-Inhalten mithilfe von XPath-Abfragen.

    Args:
        response (Response): Antwortobjekt.
        xpath_queries (Dict[str, str]): Wörterbuch mit XPath-Abfragen für die Datenextraktion.

    Returns:
        Dict[str, str]: Wörterbuch mit extrahierten Daten für jede XPath-Abfrage.
    """
    extracted_data = {}
    tree = html.fromstring(response.text)
    for key, xpath_query in xpath_queries.items():
        data = tree.xpath(xpath_query)[0].strip()
        extracted_data[key] = data
    return extracted_data


def save_to_csv(extracted_data: Dict[str, any]):
    """
    Speichert ein Wörterbuch als Zeile in einer CSV-Datei mit DictWriter.

    Args:
        extracted_data (Dict[str, any]): Wörterbuch, das eine Datenzeile darstellt.
    """
    csv_file_path = "product_data.csv"
    fieldnames = ["title", "ratings", "price"]
    with open(csv_file_path, "a", newline="") as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        if csvfile.tell() == 0:
            writer.writeheader()  # Kopfzeile nur schreiben, wenn die Datei leer ist
        writer.writerow(extracted_data)


def main():
    # Lesen von URLs aus einer CSV-Datei
    urls = []
    with open("amazon_product_urls.csv", "r") as file:
        reader = csv.DictReader(file)
        for row in reader:
            urls.append(row["url"])

    # Definieren von Anfrage-Headern
    headers = {
        "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
        "accept-language": "en-IN,en;q=0.9",
        "dnt": "1",
        "sec-ch-ua": '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
        "sec-ch-ua-mobile": "?0",
        "sec-ch-ua-platform": '"Windows"',
        "sec-fetch-dest": "document",
        "sec-fetch-mode": "navigate",
        "sec-fetch-site": "same-origin",
        "sec-fetch-user": "?1",
        "upgrade-insecure-requests": "1",
        "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",
    }

    useragents = [
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4591.54 Safari/537.36",
        "Mozilla/5.0 (Windows NT 7_0_2; Win64; x64) AppleWebKit/541.38 (KHTML, like Gecko) Chrome/105.0.1585 Safari/537.36",
        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.7863.44 Safari/537.36"
        ]

    # Definition von Proxys
    proxies = {"http": "IP:Port", "https": "IP:Port"}

    # Senden von Anfragen an URLs
    for url in urls:
        # Useragent Rotation in Kopfzeilen
        headers["user-agent"] = random.choice(useragnets)
        response = send_requests(url, headers, proxies)
        if response:
            # Extrahieren von Daten aus HTML-Inhalten
            xpath_queries = {
                "title": '//span[@id="productTitle"]/text()',
                "ratings": '//span[@id="acrPopover"]/@title',
                "price": '//span[@class="a-offscreen"]/text()',
            }
            extracted_data = extract_data_from_html(response, xpath_queries)

            # Speichern der extrahierten Daten in einer CSV-Datei
            save_to_csv(extracted_data)


if __name__ == "__main__":
    main()

Proxy-Vorschläge für das Scrapen von Amazon durch Python

Für die unterbrechungsfreie Datenextraktion stehen verschiedene Proxy-Lösungen zur Verfügung, darunter IPv4-Proxys für Rechenzentren, rotierende mobile Proxys, ISP-Proxys und Proxys für Privatanwender. Eine geeignete Rotationslogik und Benutzeragenten werden verwendet, um das reale Benutzerverhalten zu simulieren, während spezielle Proxys das Scraping im großen Stil mit interner Rotation und umfangreichen IP-Pools unterstützen. Für eine unterbrechungsfreie Datenextraktion ist es wichtig, die Vor- und Nachteile der einzelnen Proxy-Optionen zu kennen.

Das Scraping von Produktdaten von Amazon erfordert eine sorgfältige Vorbereitung, um die Anti-Scraping-Mechanismen der Plattform effektiv zu umgehen. Die Verwendung von Proxy-Servern zusammen mit Python ermöglicht eine effiziente Datenverarbeitung und eine gezielte Extraktion der erforderlichen Informationen. Bei der Auswahl von Proxys für Web-Scraping müssen Faktoren wie Leistung, Kosten, Serverzuverlässigkeit und die spezifischen Anforderungen Ihres Projekts berücksichtigt werden. Der Einsatz von dynamischen Proxys und die Implementierung von Strategien, die Sicherheitsmaßnahmen entgegenwirken, können das Risiko, blockiert zu werden, minimieren und die Gesamteffizienz des Scraping-Prozesses erhöhen.