Farfetch ist eine der größten Luxusmodeplattformen mit Tausenden von hochwertigen Kleidungsstücken, Schuhen und Accessoires von Top-Marken aus aller Welt. Egal, ob Sie Marktforschung betreiben, Luxusmodetrends analysieren oder Ihre E-Commerce-Datenbank aufbauen, das Scraping von Daten von Farfetch kann sehr nützlich sein.

Wie viele andere Websites verwendet Farfetch jedoch JavaScript, um seine Inhalte zu laden, sodass herkömmliche Scraper die benötigten Einzelhandelsdaten nicht extrahieren können. Hier kommt der Crawlbase Crawling API kommt ins Spiel. Es vereinfacht das Scraping, indem es JavaScript-Inhalte verarbeitet, Proxys verwaltet und Anti-Bot-Mechanismen umgeht – und das alles mit nur wenigen Codezeilen in Python.

In diesem Blog durchsuchen wir die SERPs und Produktseiten von Farfetch mit der Crawlbase Crawling API bei Python.

Inhaltsverzeichnis

  1. Vorteile des Farfetch Data Scraping
  2. Wichtige Datenpunkte zum Extrahieren von Farfetch
  3. Crawlbase Crawling API für Farfetch Scraping
  • Crawlbase Python-Bibliothek
  1. So richten Sie Ihre Python-Umgebung ein
  • Installieren von Python und erforderlichen Bibliotheken
  • Auswahl einer IDE
  1. Scraping von Farfetch-Suchergebnissen
  • Untersuchen des HTML auf CSS-Selektoren
  • Schreiben des Suchlisten-Scrapers
  • Umgang mit der Seitennummerierung in Farfetch
  • Speichern von Daten in einer CSV-Datei
  • Vollständiges Codebeispiel
  1. Scraping von Farfetch-Produktseiten
  • Untersuchen des HTML auf CSS-Selektoren
  • Schreiben des Produktseiten-Scrapers
  • Speichern von Daten in einer CSV-Datei
  • Vollständiges Codebeispiel
  1. Abschließende Überlegungen
  2. Häufig gestellte Fragen

Vorteile des Farfetch Data Scraping

Farfetch ist einer der größten Akteure auf dem Luxusmodemarkt und verbindet Verbraucher mit Geschäften und High-End-Marken. Farfetch ist eine Fundgrube für Unternehmen, Wissenschaftler und Entwickler und bietet Tausende von Produkten, von hochwertiger Kleidung bis hin zu Accessoires.

Vorteile von Farfetch Data Scraping zum Extrahieren von Einzelhandelsinformationen

Durch das Scraping von Farfetch erhalten Sie Einblicke in:

  • Preistrends: Wie Luxusprodukte marken-, kategorien- und regionsübergreifend bepreist werden.
  • Produktverfügbarkeit: Verfolgen Sie Lagerbestände und Verfügbarkeit, um zu sehen, was sich schnell verkauft und welche Marken beliebt sind.
  • Markt-Trends: Finden Sie Modetrends, saisonale Neuheiten und neue Marken.
  • Wettbewerbsanalyse: Vergleichen Sie Preise, Produktbeschreibungen und Rabatte mit denen der Konkurrenz.
  • Erstellen von Datenbanken: Erstellen Sie eine saubere Produktdatenbank mit Titeln, Beschreibungen, Preisen, Bildern und mehr.

Wichtige Datenpunkte zum Extrahieren von Farfetch

Konzentrieren Sie sich beim Scraping von Farfetch auf diese Datenpunkte:

  1. Klappentext: Eine kurze Beschreibung, die Ihnen bei der Identifizierung des Produkts hilft.
  2. Marke: Verfolgen und identifizieren Sie die Luxusmarken auf der Plattform.
  3. Preis: Erhalten Sie sowohl Originalpreise als auch ermäßigte Preise.
  4. Beschreibung: Sammeln Sie Informationen zu Materialien und Funktionen für die Katalogisierung.
  5. Größen und Verfügbarkeit: Überwachen Sie den Lagerstatus und die Nachfrage für beliebte Größen.
  6. Kategorien: Analysieren Sie Trends innerhalb bestimmter Produktsegmente.
  7. Bilder: Extrahieren Sie URLs von Produktbildern für visuelle Datenbanken.
  8. Bewertungen und Rezensionen: Kundenpräferenzen verstehen und Produktqualität beurteilen.
  9. Regionale Preise: Vergleichen Sie Preise verschiedener Währungen und Regionen.
  10. Lieferoptionen: Versanddauer und -kosten auswerten.

Durch das Sammeln dieser Datenpunkte können Sie Erkenntnisse für die Marktforschung und das Geschäftswachstum gewinnen. Sehen wir uns nun an, wie Sie Farfetch mit Crawlbase scrapen können Crawling API.

Crawlbase Crawling API für Farfetch Scraping

Die Crawlbase Crawling API ist ein Web Scraping-Tool, das die Datenextraktion aus Farfetch vereinfacht. Es übernimmt JavaScript-Rendering, Proxys und CAPTCHA-Lösungen, sodass Sie sich ohne technische Probleme auf die Erstellung Ihres Scrapers konzentrieren können.

Crawlbase Python-Bibliothek

Crawlbase hat auch eine Python-Bibliothek um die API-Integration zu vereinfachen. Sobald Sie Registrierenerhalten Sie einen Zugriffstoken zur Authentifizierung. Hier ist ein kurzes Beispiel für die Verwendung:

1
2
3
4
5
6
7
8
9
10
11
12
13
für Crawlbase importieren CrawlingAPI

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'IHR_CRAWLBASE_TOKEN'})

def Seiteninhalt abrufen(URL):
    Antwort = crawling_api.get(URL)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Fehler beim Abrufen der Seite. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

Die wichtigsten Punkte:

  • Crawlbase verfügt über separate Token für das Scraping statischer und dynamischer Inhalte.
  • Verwenden Sie ein JavaScript (JS)-Token zum Scraping dynamischer Inhalte von Farfetch.
  • Crawlbase Crawling API kümmert sich für Sie um das JavaScript-Rendering und die Proxys.

So richten Sie Ihre Python-Umgebung ein

Bevor Sie mit dem Scraping von Farfetch beginnen, müssen Sie Ihre Python-Umgebung einrichten. Dies führt Sie durch den Prozess der Installation von Python, der Einrichtung der erforderlichen Bibliotheken und der Auswahl einer IDE für Ihre Anforderungen.

Installieren von Python und erforderlichen Bibliotheken

  1. Installieren Sie Python:
  • Gehen Sie zu python.org und laden Sie die neueste Version von Python herunter.
  • Achten Sie darauf, während der Installation die Option „Python zu PATH hinzufügen“ zu aktivieren.
  1. Erforderliche Bibliotheken installieren:
  • Öffnen Sie ein Terminal oder eine Eingabeaufforderung und führen Sie den folgenden Befehl aus:
1
pip installieren crawlbase beautifulsoup4
  • Diese Bibliotheken sind für das Web Scraping und die Nutzung der Crawlbase von entscheidender Bedeutung Crawling API.

Auswahl einer IDE

Zum Schreiben und Verwalten Ihres Codes benötigen Sie eine IDE oder einen Code-Editor. Hier sind einige Optionen:

  • PyCharm: Eine voll funktionsfähige IDE mit erweiterten Debugging- und Code-Navigationstools
  • Visual Studio Code: Ein leichter und anpassbarer Editor mit Erweiterungen für Python.
  • Jupyter Notizbuch: Zum interaktiven Testen und Ausführen von Codeausschnitten.

Wählen Sie die IDE, die zu Ihnen passt, und schon kann es losgehen. Im nächsten Abschnitt beschäftigen wir uns mit dem Scraping der Suchlisten von Farfetch.

Scraping von Farfetch-Suchergebnissen

Nachdem Sie nun Ihre Python-Umgebung eingerichtet haben, können wir mit dem Scrapen der Suchergebnisse von Farfetch beginnen. In diesem Abschnitt erfahren Sie, wie Sie das HTML überprüfen, einen Scraper erstellen, die Paginierung verwalten und die Daten in einer CSV-Datei speichern.

Überprüfen der HTML-Struktur

Bevor wir den Scraper schreiben, müssen wir das HTML der Suchergebnisse von Farfetch überprüfen, um die Produkttitel, Preise und Links zu finden. Für dieses Beispiel verwenden wir eine Kategorie wie „Herren-Sneaker“ von der folgenden URL.

1
https://www.farfetch.com/pk/shopping/men/trainers-2/items.aspx
  1. Öffnen Sie die Entwicklertools: Gehen Sie zur URL und drücken Sie Ctrl + Shift + I (oder Cmd + Option + I auf dem Mac), um die Entwicklertools Ihres Browsers zu öffnen.
  2. Produktelemente prüfen: Bewegen Sie den Mauszeiger über die Produkttitel, Preise und Links, um die entsprechenden Tags und CSS-Klassen zu finden.
Bild zum Scrapen der HTML-Struktur – Farfetch-Sucheinträge

Wichtige Auswahlkriterien für die Suchlisten von Farfetch:

  • Marke: Gefunden in einem <p> Tag mit dem data-component="ProductCardBrandName" Attribut.
  • Beschreibung: Gefunden in einem <p> Tag mit dem data-component="ProductCardDescription" Attribut.
  • Preis: Gefunden in einem <p> Tag mit dem data-component="Price" or data-component="PriceFinal" Attribut.
  • Rabatt: Gefunden in einem <p> Tag mit dem data-component="PriceDiscount" Attribut.
  • Produktlink: Gefunden in einem <a> Tag innerhalb des Produktcontainers. Das href-Attribut stellt den Produktlink bereit, mit dem Präfix https://www.farfetch.com.

Schreiben des Suchlisten-Scrapers

Hier ist ein Python-Skript zum Scrapen von Produktdaten mit Crawlbase und BeautifulSoup Bibliotheken:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'IHR_CRAWLBASE_TOKEN'})

# Funktion zum Scrapen von Farfetch-Suchlisten
def scrape_farfetch_listings(URL):
    Optionen = {
        'ajax_wait': "wahr",  # Warten Sie, bis JavaScript geladen ist
        'Seite_warten': '5000'   # Warten Sie 5 Sekunden, bis die Seite geladen ist
    }
    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':  # Crawlbase-Status prüfen
        Suppe = Schöne Suppe(Antwort['Körper'].dekodieren('utf-8'), "html.parser")
        Produkte = []

        # Produktdetails extrahieren
        
für Artikel in Suppe.Auswählen('ul#catalog-grid > li[data-testid="productCard"]'):
            Marke = Artikel.Wählen Sie einen aus('p[data-component="ProduktKartenMarkenname"]').text.strip() if Element.Wählen Sie eins aus('p[data-component="ProduktKartenMarkenname"]') sonst "N / A"
            Beschreibung = Element.Wählen Sie eins aus('p[data-component="Produktkartenbeschreibung"]').text.strip() if Element.Wählen Sie eins aus('p[data-component="Produktkartenbeschreibung"]') sonst "N / A"
            Preis = Artikel.Wählen Sie einen Artikel aus('p[Datenkomponente="Preis"], p[Datenkomponente="PreisFinal"]').text.strip() if Element.Wählen Sie eins aus('p[Datenkomponente="Preis"], p[Datenkomponente="PreisFinal"]') sonst "N / A"
            Rabatt = Artikel.Wählen Sie einen aus('p[data-component="Preisnachlass"]').text.strip() if Element.Wählen Sie eins aus('p[data-component="Preisnachlass"]') sonst "N / A"
            Link = Element.Wählen Sie eins aus("ein")["href"] if Element.Wählen Sie eins aus("ein") sonst "N / A"

            Produkte.anhängen({"Marke": Marke, „Beschreibung“: Beschreibung, "Preis": Preis, "Rabatt": Rabatt, "Verknüpfung": f"https://www.farfetch.com{Verknüpfung}"})

        Rückkehr Produkte
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr []

# Beispielverwendung
URL = „https://www.farfetch.com/shopping/men/shoes-2/items.aspx“
Produkte = scrape_farfetch_listings(URL)

für PRODUKTE in Produkte:
    drucken(Produkt)

Dieser Code definiert eine Funktion, scrape_farfetch_listings, um Produktdetails aus den Suchergebnissen von Farfetch zu extrahieren. Es sendet eine Anfrage an Crawlbase Crawling API um Farfetch SERP HTML zu erhalten. Es verwendet ajax_wait und page_wait von Crawlbase bereitgestellte Parameter Crawling API um JS-Inhalte zu verarbeiten. Sie können über diese Parameter lesen HIER.

Wenn die Anfrage erfolgreich ist, verwendet die Funktion BeautifulSoup, um das zurückgegebene HTML zu analysieren und Produktdetails für jede Produktkarte zu extrahieren. Die extrahierten Daten werden als Wörterbücher in einer Liste gespeichert und die Funktion gibt die Liste der Produkte zurück.

Umgang mit der Seitennummerierung in Farfetch

Farfetch listet Produkte auf mehreren Seiten auf. Um alle Einträge abzurufen, durchlaufen Sie jede Seite, indem Sie den Seitenparameter an die URL anhängen (z. B. ?page=2).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def Mehrere Seiten auslesen(Basis-URL, Gesamtseiten):
    alle_produkte = []

    
für Seite in Angebot(1, Gesamtseitenzahl + 1):
        paginierte_URL = f"{base_url}?Seite={Seite}"
        drucken(f"Scraping-Seite: {Seite}")
        Produkte = scrape_farfetch_listings(paginierte_URL)
        alle_produkte.erweitern(Produkte)

    Rückkehr alle_produkte

# Beispielverwendung
Basis-URL = „https://www.farfetch.com/shopping/men/shoes-2/items.aspx“
alle_produkte = mehrere_seiten_abrufen(Basis-URL, Gesamtseitenzahl=5)
drucken(f"Insgesamt verschrottete Produkte: {len(alle_produkte)}")

Speichern von Daten in einer CSV-Datei

Speichern Sie die Daten nach dem Scraping zur weiteren Analyse in einer CSV-Datei.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
importieren csv

# Funktion zum Speichern von Daten in CSV
def als CSV speichern(Daten, Dateiname="farfetch_listings.csv"):
    Schlüssel = Daten[0].Schlüssel()

    mit XNUMXh geöffnet(Dateiname, Modus="w", neue Zeile="", Kodierung="utf-8") as Datei:
        Writer = csv.DictWriter(Datei, Feldnamen=Schlüssel)
        Writer.writeheader()
        writer.writerows(Daten)

    drucken(f"Daten gespeichert in {Dateiname}")

# Speichern Sie die Scraped-Daten
if alle_produkte:
    in CSV speichern (alle Produkte)

Vollständiges Codebeispiel

Unten finden Sie das vollständige Skript zum Scrapen der Suchlisten von Farfetch mit Crawlbase Crawling API, handhaben Sie die Paginierung und speichern Sie die Daten in einer CSV-Datei:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren csv

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'IHR_CRAWLBASE_TOKEN'})

# Funktion zum Scrapen von Farfetch-Suchlisten
def scrape_farfetch_listings(URL):
    Optionen = {
        'ajax_wait': "wahr",  # Warten Sie, bis JavaScript geladen ist
        'Seite_warten': '5000'   # Warten Sie 5 Sekunden, bis die Seite geladen ist
    }
    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':  # Crawlbase-Status prüfen
        Suppe = Schöne Suppe(Antwort['Körper'].dekodieren('utf-8'), "html.parser")
        Produkte = []

        # Produktdetails extrahieren
        
für Artikel in Suppe.Auswählen('ul#catalog-grid > li[data-testid="productCard"]'):
            Marke = Artikel.Wählen Sie einen aus('p[data-component="ProduktKartenMarkenname"]').text.strip() if Element.Wählen Sie eins aus('p[data-component="ProduktKartenMarkenname"]') sonst "N / A"
            Beschreibung = Element.Wählen Sie eins aus('p[data-component="Produktkartenbeschreibung"]').text.strip() if Element.Wählen Sie eins aus('p[data-component="Produktkartenbeschreibung"]') sonst "N / A"
            Preis = Artikel.Wählen Sie einen Artikel aus('p[Datenkomponente="Preis"], p[Datenkomponente="PreisFinal"]').text.strip() if Element.Wählen Sie eins aus('p[Datenkomponente="Preis"], p[Datenkomponente="PreisFinal"]') sonst "N / A"
            Rabatt = Artikel.Wählen Sie einen aus('p[data-component="Preisnachlass"]').text.strip() if Element.Wählen Sie eins aus('p[data-component="Preisnachlass"]') sonst "N / A"
            Link = Element.Wählen Sie eins aus("ein")["href"] if Element.Wählen Sie eins aus("ein") sonst "N / A"

            Produkte.anhängen({"Marke": Marke, „Beschreibung“: Beschreibung, "Preis": Preis, "Rabatt": Rabatt, "Verknüpfung": f"https://www.farfetch.com{Verknüpfung}"})

        Rückkehr Produkte
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr []

# Funktion zum Scrapen mehrerer Seiten
def Mehrere Seiten auslesen(Basis-URL, Gesamtseiten):
    alle_produkte = []

    
für Seite in Angebot(1, Gesamtseitenzahl + 1):
        paginierte_URL = f"{base_url}?Seite={Seite}"
        drucken(f"Scraping-Seite: {Seite}")
        Produkte = scrape_farfetch_listings(paginierte_URL)
        alle_produkte.erweitern(Produkte)

    Rückkehr alle_produkte

# Funktion zum Speichern von Daten in CSV
def als CSV speichern(Daten, Dateiname="farfetch_listings.csv"):
    Schlüssel = Daten[0].Schlüssel()

    mit XNUMXh geöffnet(Dateiname, Modus="w", neue Zeile="", Kodierung="utf-8") as Datei:
        Writer = csv.DictWriter(Datei, Feldnamen=Schlüssel)
        Writer.writeheader()
        writer.writerows(Daten)

    drucken(f"Daten gespeichert in {Dateiname}")

# Suchlisten von Farfetch scrapen
Basis-URL = „https://www.farfetch.com/shopping/men/shoes-2/items.aspx“
alle_produkte = mehrere_seiten_abrufen(Basis-URL, Gesamtseitenzahl=5)

# Ergebnisse als CSV speichern
if alle_produkte:
    in CSV speichern (alle Produkte)

farfetch_listings.csv Datei-Snapshot:

Snapshot der Datei farfetch_listings.csv

Im nächsten Abschnitt untersuchen wir das Scraping einzelner Produktseiten zur Gewinnung detaillierterer Daten.

Scraping von Farfetch-Produktseiten

Nachdem Sie nun die Produktlisten gescrapt haben, besteht der nächste Schritt darin, einzelne Produktseiten zu scrapen, um Produktbeschreibungen, Größen, Materialien und mehr zu erhalten. Hier zeigen wir Ihnen, wie Sie das HTML prüfen, einen Scraper für Produktseiten schreiben und die Daten in einer CSV-Datei speichern.

Untersuchen des HTML auf CSS-Selektoren

Besuchen Sie beispielsweise eine Farfetch-Produktseite:

1
https://www.farfetch.com/pk/shopping/men/gucci-screener-sneakers-item-27582236.aspx

Öffnen Sie die Entwicklertools in Ihrem Browser (Ctrl + Shift + I or Cmd + Option + I auf dem Mac) und überprüfen Sie die Schlüsselelemente, die Sie scrapen möchten.

Bild zum Scraping der HTML-Struktur – Farfetch-Produktseiten

Wichtige Auswahlkriterien für die Produktseiten von Farfetch:

  • Klappentext: Befindet sich in einem <p> tag mit data-testid="product-short-description".
  • Markenname: Befindet sich in einem <a> tag mit data-component="LinkGhostDark".
  • Preis: Befindet sich in einem <div> tag mit id="price".
  • Beschreibung: Befindet sich in einem verschachtelten <div> mit data-component="AccordionPanel" mit ist innerhalb eines div mit data-testid="product-information-accordion".

Schreiben des Produktseiten-Scrapers

Hier ist ein Python-Skript zum Scrapen von Produktdetails mit Crawlbase und BeautifulSoap:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'IHR_CRAWLBASE_TOKEN'})

# Funktion zum Scrapen von Details von einer Produktseite mithilfe von Crawlbase
def Produktseite scrapen(URL):
    Optionen = {
        "ajax_wait": "True",  # Warten Sie auf das JavaScript-Rendering
        "Seite_warten": "3000"   # Warten Sie 3 Sekunden, bis die Seite vollständig geladen ist
    }
    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Suppe = Schöne Suppe(Antwort['Körper'], "html.parser")

        # Produktdetails extrahieren
        Klappentext = Suppe.select_one('p[data-testid="Produkt-Kurzbeschreibung"]').text.strip() if Suppe.Wähle eine('p[data-testid="Produkt-Kurzbeschreibung"]') sonst "N / A"
        Marke = Suppe.select_one('a[Datenkomponente="LinkGhostDark"]').text.strip() if Suppe.Wähle eine('a[Datenkomponente="LinkGhostDark"]') sonst "N / A"
        Preis = Suppe.select_one('div#Preis').text.strip() if Suppe.Wähle eine('div#Preis') sonst "N / A"
        Beschreibung = Suppe.select_one('div[data-testid="Produktinformations-Akkordeon"] div[data-component="AccordionPanel"]').text.strip() if Suppe.Wähle eine('div[data-testid="Produktinformations-Akkordeon"] div[data-component="AccordionPanel"]') sonst "N / A"

        Rückkehr {
            "Klappentext": Klappentext,
            "Marke": Marke,
            "Preis": Preis,
            „Beschreibung“: Beschreibung
        }
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

# Beispielverwendung
URL = „https://www.farfetch.com/shopping/men/sneakers-product-12345.aspx“
Produktdetails = Produktseite scrapen (URL)
drucken(Produktdetails)

Die scrape_product_page Die Funktion stellt eine HTTP-Anfrage an die angegebene URL mit Optionen zum Rendern von JavaScript. Anschließend verwendet sie BeautifulSoup, um das HTML zu analysieren und Klappentext, Marke, Preis, Beschreibung und Größen zu extrahieren. Die Daten werden als Wörterbuch zurückgegeben. Wenn die Anfrage fehlschlägt, wird ein Fehler ausgegeben.

Speichern von Daten in einer CSV-Datei

Sobald Sie Produktdetails gesammelt haben, können Sie diese für einen einfacheren Zugriff in einer CSV-Datei speichern.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importieren csv

# Funktion zum Speichern von Produktdaten in einer CSV-Datei
def Produkt als CSV speichern(Produktdaten, Dateiname="farfetch_product_details.csv"):
    Schlüssel = Produktdaten.Schlüssel()

    # Header und Daten schreiben
    mit XNUMXh geöffnet(Dateiname, Modus="w", neue Zeile="", Kodierung="utf-8") as Datei:
        Writer = csv.DictWriter(Datei, Feldnamen=Schlüssel)
        Writer.writeheader()
        writer.writerow(Produktdaten)

    drucken(f"Produktdaten gespeichert in {Dateiname}")

# Beispielverwendung
if produkt_details:
    Produkt als CSV speichern (Produktdetails)

Vollständiges Codebeispiel

Hier ist das vollständige Skript zum Scrapen einer Farfetch-Produktseite mit Crawlbase Crawling API und Speichern der Daten in einer CSV-Datei:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren csv

# Initialisieren Sie die Crawlbase-API mit Ihrem Zugriffstoken
crawling_api = CrawlingAPI({'Zeichen': 'IHR_CRAWLBASE_TOKEN'})

# Funktion zum Scrapen von Details von einer Produktseite mithilfe von Crawlbase
def Produktseite scrapen(URL):
    Optionen = {
        "ajax_wait": "True",  # Warten Sie auf das JavaScript-Rendering
        "Seite_warten": "3000"   # Warten Sie 3 Sekunden, bis die Seite vollständig geladen ist
    }
    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Suppe = Schöne Suppe(Antwort['Körper'], "html.parser")

        # Produktdetails extrahieren
        Klappentext = Suppe.select_one('p[data-testid="Produkt-Kurzbeschreibung"]').text.strip() if Suppe.Wähle eine('p[data-testid="Produkt-Kurzbeschreibung"]') sonst "N / A"
        Marke = Suppe.select_one('a[Datenkomponente="LinkGhostDark"]').text.strip() if Suppe.Wähle eine('a[Datenkomponente="LinkGhostDark"]') sonst "N / A"
        Preis = Suppe.select_one('div#Preis').text.strip() if Suppe.Wähle eine('div#Preis') sonst "N / A"
        Beschreibung = Suppe.select_one('div[data-testid="Produktinformations-Akkordeon"] div[data-component="AccordionPanel"]').text.strip() if Suppe.Wähle eine('div[data-testid="Produktinformations-Akkordeon"] div[data-component="AccordionPanel"]') sonst "N / A"

        Rückkehr {
            "Klappentext": Klappentext,
            "Marke": Marke,
            "Preis": Preis,
            „Beschreibung“: Beschreibung
        }
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

# Funktion zum Speichern von Produktdaten in einer CSV-Datei
def Produkt als CSV speichern(Produktdaten, Dateiname="farfetch_product_details.csv"):
    Schlüssel = Produktdaten.Schlüssel()

    mit XNUMXh geöffnet(Dateiname, Modus="w", neue Zeile="", Kodierung="utf-8") as Datei:
        Writer = csv.DictWriter(Datei, Feldnamen=Schlüssel)
        Writer.writeheader()
        writer.writerow(Produktdaten)

    drucken(f"Produktdaten gespeichert in {Dateiname}")

# Beispielverwendung
produkt_url = „https://www.farfetch.com/shopping/men/sneakers-product-12345.aspx“
Produktdetails = Produktseite scrapen (Produkt-URL)

if produkt_details:
    Produkt als CSV speichern (Produktdetails)

farfetch_product_details.csv Datei-Snapshot:

Datei „farfetch_product_details.csv“ – Momentaufnahme

Abschließende Überlegungen

Durch das Scraping von Farfetch können Sie wertvolle Daten für Marktforschung, Preisanalyse und um im Modegeschäft die Nase vorn zu behalten, erhalten. Crawlbase Crawling API und Bibliotheken wie BeautifulSoup können Sie Produktdetails scrapen, die Datenerfassung automatisieren und Ihren Arbeitsablauf optimieren.

Denken Sie jedoch daran, die Nutzungsbedingungen der Website und ethisches Scraping zu respektieren. Mit dem Code und den Anleitungen in diesem Blog können Sie die Such- und Produktseiten von Farfetch problemlos scrapen. Möchten Sie weitere Websites scrapen? Sehen Sie sich unsere anderen Anleitungen an.

📜 So scrapen Sie Monster.com
📜 Wie man Groupon scrapt
📜 So scrapen Sie TechCrunch
📜 So scrapen Sie Tweet-Seiten von X.com
📜 Wie man Clutch.co scrapt

Wenn Sie Fragen haben oder Feedback geben möchten, unsere Support-Team kann beim Web Scraping helfen. Viel Spaß beim Scraping!

Häufig gestellte Fragen

F: Wie gehe ich mit JavaScript-Inhalten um, wenn ich Farfetch scrape?

Beim Scraping dynamischer Websites wie Farfetch werden JavaScript-Inhalte möglicherweise nicht sofort geladen. Verwenden Sie die Crawlbase Crawling API, das JavaScript-Rendering unterstützt. Dadurch wird sichergestellt, dass die Seite vollständig geladen ist, einschließlich dynamischer Inhalte, bevor Sie die Daten extrahieren. Sie können die Option ajax_wait in der API-Anforderung auf true setzen, um JavaScript genügend Zeit zum Rendern der Seite zu geben.

F: Kann ich Produktdetails von mehreren Seiten auf Farfetch extrahieren?

Ja, Sie können Produktdetails von mehreren Seiten auf Farfetch abrufen. Dazu müssen Sie die Seitennummerierung verwalten. Sie können die URL anpassen, um einen Seitennummernparameter einzuschließen und Einträge von jeder Seite in einer Schleife abzurufen. In Verbindung mit der Crawlbase Crawling API, könnten Sie mehrere Seiten durchsuchen, ohne Angst vor einer Sperre haben zu müssen.

F: Wie speichere ich die Scraped-Daten?

Nach dem Scraping von Daten aus Farfetch ist es wichtig, diese in einem organisierten Format zu speichern. Sie können die Daten in CSV- oder JSON-Dateien speichern, um einfach darauf zugreifen und sie später verwenden zu können. Beispielsweise kann der Code die gescrapten Produktdetails in eine CSV-Datei schreiben und so sicherstellen, dass die Informationen strukturiert gespeichert werden, was ideal für die Analyse oder Weitergabe ist.