Zoro bietet über 12 Millionen Produkte, Werkzeuge, Geräte und Industriebedarf. Zoro ist einfach zu bedienen und ein One-Stop-Shop für Unternehmen und Privatpersonen, die nach Produkten mit detaillierten Beschreibungen, Preisen und Verfügbarkeit suchen. Mit Millionen von Besuchern pro Monat ist Zoro ein großer Akteur auf dem Markt für Industriebedarf.

In diesem Blog erfahren Sie, wie Sie mit Python Daten aus Zoro extrahieren und Crawlbase Crawling API. Du wirst es lernen:

  • So scrapen Sie Zoro-Suchergebnisse.
  • Erhalten Sie Produktdetails wie Preise, Lagerstatus und Spezifikationen.
  • Behandeln Sie mit JavaScript gerenderte Inhalte und Seitennummerierung.

Lass uns loslegen!

Inhaltsverzeichnis

  1. Warum Daten aus Zoro extrahieren?
  2. Wichtige Datenpunkte zum Extrahieren aus Zoro
  3. Crawlbase Crawling API für Zoro Scraping
  4. Vorbereitung für Zoro Data Scraping
  • Erforderliche Tools und Bibliotheken
  • Installieren und Konfigurieren von Crawlbase
  1. Scraping von Zoro-Sucheinträgen
  • Untersuchen von HTML zum Identifizieren von Selektoren
  • Schreiben des Suchlisten-Scrapers
  • Handhabung der Paginierung mit dem Parameter „page“
  • Speichern von Scraped-Daten in einer JSON-Datei
  • Vollständiges Codebeispiel
  1. Scraping von Zoro-Produktseiten
  • Die Struktur von Produktseiten verstehen
  • Extrahieren wichtiger Details aus Produkten
  • Produktdaten in einer JSON-Datei speichern
  • Vollständiges Codebeispiel
  1. Abschließende Überlegungen
  2. Häufig gestellte Fragen (FAQs)

Warum Daten aus Zoro extrahieren?

Das Scraping von Zoro kann für Unternehmen, Forscher und Entwickler sehr nützlich sein. Mit so vielen Produkten und so vielen Details ist Zoro eine wahre Fundgrube an Daten für Analysen und Marktforschung. Hier ist der Grund:

1. Marktforschung

Erhalten Sie Produktinformationen, einschließlich Spezifikationen, Preisen und Verfügbarkeit, um Markttrends zu analysieren und Top-Produkte in verschiedenen Kategorien zu finden.

2. Preisvergleich

Verwenden Sie Zoro-Daten, um die Preise der Wettbewerber zu vergleichen und fundierte Kaufentscheidungen zu treffen oder Ihre Preise anzupassen, um wettbewerbsfähig zu bleiben.

3. Bestandsverwaltung

Verfolgen Sie die Produktverfügbarkeit und den Lagerstatus, um Ihren Bestand zu optimieren und Fehlbestände oder Überbestände zu vermeiden.

4. Daten für E-Commerce-Projekte

Mit den von Zoro extrahierten Daten können E-Commerce-Plattformen, Produktvergleichstools oder Katalogverwaltungssysteme erstellt oder verbessert werden.

5. Geschäftsintelligenz

Informieren Sie sich über die Kundennachfrage und Produktpopularität, indem Sie die Produktlisten und Bewertungen von Zoro analysieren.

Wichtige Datenpunkte zum Extrahieren aus Zoro

Beim Scraping von Zoro müssen Sie die richtigen Datenpunkte extrahieren, um aussagekräftige Erkenntnisse zu erhalten. Hier erfahren Sie, worauf Sie sich konzentrieren sollten:

Ein Bild der wichtigsten Datenpunkte, die aus Zoro extrahiert werden können

Crawlbase Crawling API für Zoro Scraping

Die Crawlbase Crawling API eignet sich perfekt zum Scraping von JavaScript-gerenderten Websites wie Zoro. Es verarbeitet dynamische Inhalte, umgeht Anti-Scraping-Maßnahmen und vereinfacht die Verwaltung der Seitennummerierung.

Um Crawlbase zu verwenden, installieren Sie die Python-Bibliothek mit:

1
pip installieren crawlbase

Nacher Anmeldung Rufen Sie für Crawlbase Ihr API-Token vom Dashboard ab. Dieses Token ist für alle Anfragen erforderlich. Crawlbase bietet zwei Arten von Token an. Ein normales Token für statische Websites und ein JS-Token für JS-gerenderte Websites. Für Zoro benötigen Sie ein JS-Token. Crawlbase bietet 1,000 Anfragen kostenlos für seine Crawling API für einen einfachen Start.

Crawlbase Crawling API ermöglicht Ihnen die Darstellung von JavaScript mit dem ajax_wait Option und bewältigen Sie langsamere Seitenladezeiten mit page_waitEs gibt viele andere Optionen, die Sie mit Crawlbase nutzen können Crawling API; Sie können darüber lesen HIER.

So rufen Sie eine Zoro-Suchseite ab:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
für Crawlbase importieren CrawlingAPI

# Crawlbase API initialisieren
crawling_api = CrawlingAPI({'Zeichen': 'IHR_CRAWLBASE_API_TOKEN'})

# Parameter definieren
Optionen = {
'ajax_wait': "wahr", # Sicherstellen, dass JavaScript-Inhalte geladen werden
'Seite_warten': '2000', # Bei langsamen Seiten 2 Sekunden warten
}

# URL der Zoro-Suchseite
URL = „https://www.zoro.com/search?q=tools&page=1“

# Seite mit Crawlbase abrufen
Antwort = crawling_api.get(URL, Optionen)

if Antwort['Kopfzeilen']['pc_status'] == '200':
html_content = Antwort['Körper'].dekodieren('utf-8')
drucken("Daten erfolgreich abgerufen!")
sonst:
drucken("Daten konnten nicht abgerufen werden.")

Diese Konfiguration bereitet den Boden für den Aufbau von Scrapern für Zoros Listen und Produktseiten.

Vorbereitung für Zoro Data Scraping

Bevor Sie mit dem Scraping von Zoro beginnen, müssen Sie Ihre Umgebung mit den richtigen Tools und Bibliotheken einrichten. Hier erfahren Sie Schritt für Schritt, wie Sie loslegen.

Erforderliche Tools und Bibliotheken

Um Zoro zu scrapen, benötigen Sie:

  1. Python: Aufgrund seiner Benutzerfreundlichkeit und robusten Bibliotheken ist Python eine der besten Sprachen für Web Scraping.
  2. Crawlbase Python-Bibliothek: Dies wird Ihnen helfen, Crawlbase Crawling API Anrufe.
  3. BeautifulSuppe: Eine Python-Bibliothek zum Parsen von HTML und Extrahieren von Daten daraus.

Installieren von Python und erforderlichen Bibliotheken

Wenn Sie Python nicht installiert haben, laden Sie es hier herunter: Python.org. Nach der Installation können Sie pip verwenden, um die Bibliotheken zu installieren. Führen Sie die folgenden Befehle in Ihrem Terminal aus:

1
2
pip installieren crawlbase
pip install beautifulsoup4

Diese Bibliotheken ermöglichen Ihnen die Interaktion mit der Crawlbase Crawling API, analysieren Sie den HTML-Inhalt von Zoro und verarbeiten Sie Anfragen effektiv.

So wählen Sie die richtige IDE für Web Scraping

Zum Schreiben Ihres Scraping-Skripts können Sie jede integrierte Entwicklungsumgebung (IDE) oder jeden Texteditor verwenden. Sie können zwischen einigen der beliebtesten wählen, wie VS-Code, PyCharm und Jupyter Notizbücher.

Scraping von Zoro-Sucheinträgen

Das Scraping der Zoro-Suchlisten umfasst das Identifizieren wichtiger Datenpunkte, das Schreiben eines Python-Scrapers, das Verwalten der Paginierung und das Speichern der Daten in einem strukturierten Format. Lassen Sie uns das Schritt für Schritt durchgehen.

Untersuchen von HTML zum Identifizieren von Selektoren

Um die erforderlichen Daten zu extrahieren, überprüfen Sie die HTML-Struktur der Zoro-Suchergebnisseite:

  1. Seite öffnen: Besuchen Sie eine Zoro-Suchergebnisseite (z. B. für „Werkzeugkasten“).
  2. Untersuchen Sie die Elemente: Klicken Sie mit der rechten Maustaste auf die Seite und wählen Sie „Untersuchen“, um die Entwicklertools zu öffnen.
Ein Screenshot der Zoro Search Listings - HTML-Inspektionsstruktur
  1. Elemente lokalisieren: Verwenden Sie den DOM-Explorer, um die CSS-Selektoren für Folgendes zu finden:
  • Markenname: Gefunden in einem <span> tag mit der klasse brand-name.
  • Produkttitel: Gefunden in einem <div> tag mit der klasse product-title.
  • Preis: Gefunden in einem <div> tag mit der klasse price.
  • Produkt-URL: Gefunden im href Attribut von an <a> Tag verschachtelt in einem
    tag mit der klasse product-title.
  • Artikelbild: Gefunden im src Attribut von an <img> Tag mit dem Datenattribut data-za="product-image".

Schreiben des Suchlisten-Scrapers

Verwenden Sie die Crawlbase Crawling API um JavaScript-Rendering zu handhaben. Hier ist der Python-Scraper:

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
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren JSON

# Crawlbase API initialisieren
crawling_api = CrawlingAPI({'Zeichen': 'IHR_CRAWLBASE_TOKEN'})

# Funktion zum Scrapen von Suchlisten
def scrape_zoro_listings(Basis-URL, Seitennummer):
Basis-URL = f"{base_url}&Seite={Seitenzahl}"
Optionen = {
'ajax_wait': "wahr", # Sicherstellen, dass JavaScript-Inhalte geladen werden
'Seite_warten': '5000', # Bei langsamen Seiten 5 Sekunden warten
}
Antwort = crawling_api.get(Basis-URL, Optionen)

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

Produkte = Suppe.Auswahl('Abschnitt [data-za="Produktkartenliste"] > div.search-product-card')
für den PRODUKTE in Produkte:
Marke = Produkt.Wählen Sie eins aus('span.Markenname').text.strip() if produkt.wählen_eins('span.Markenname') sonst ''
Titel = Produkt.Wählen Sie eins aus(„div.Produkttitel“).text.strip() if produkt.wählen_eins(„div.Produkttitel“) sonst ''
Preis = Produkt.Wählen Sie eins aus('div.Preis').text.strip() if produkt.wählen_eins('div.Preis') sonst ''
url = produkt.wählen_sie_eines(„div.Produkttitel a“)['href'] if produkt.wählen_eins(„div.Produkttitel a“) sonst ''
Bild-URL = Produkt.Wählen Sie eine('img[data-za="Produktbild"]')['Quelle'] if produkt.wählen_eins('img[data-za="Produktbild"]') sonst ''

Daten.anhängen({
'Marke': Marke,
‚Titel‘: Titel,
'Preis': Preis,
'URL': f"https://www.zoro.com{URL}",
'Bild-URL': Bild-URL
})

Rückkehr die Datenerfassung
sonst:
drucken(f"Seite konnte nicht abgerufen werden {Seitenzahl}Stand: {Antwort['Kopfzeilen']['pc_status']}")
Rückkehr []

Umgang mit Paginierung

Zoro verwendet die page Parameter für die Seitennummerierung. Sie können die Seiten durchlaufen, bis eine festgelegte Anzahl von Seiten erreicht ist, oder automatisch anhalten, wenn auf einer Seite keine Daten mehr gefunden werden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def Alle Seiten auslesen(max_pages=Keine):
alle_daten = []
Seite = 1

während Wahre:
drucken(f"Seite scrapen {Seite}... ")
Seitendaten = scrape_zoro_listings(Seite)

# Die Schleife wird unterbrochen, wenn von der aktuellen Seite keine Daten zurückgegeben werden
if nicht Seitendaten:
drucken(„Keine weiteren Daten gefunden. Paginierung wird gestoppt.“)
brechen

all_data.extend(Seitendaten)
Seite += 1

# Stoppen, wenn das maximale Seitenlimit erreicht ist
if max_Seiten und Seite > max_Seiten:
drucken(f"Das maximale Limit erreicht von {max_pages} Seiten.")
brechen

Rückkehr alle_daten

Speichern von Scraped-Daten in einer JSON-Datei

Speichern Sie die gesammelten Daten für einen einfachen Zugriff in einer JSON-Datei:

1
2
3
4
def in JSON speichern(Daten, Dateiname='zoro_listings.json'):
mit XNUMXh geöffnet(Dateiname, 'w') as f:
json.dump(Daten, f, Einzug=4)
drucken(f"Daten gespeichert in {Dateiname}")

Vollständiges Codebeispiel

Hier ist das vollständige Skript, das alle Schritte kombiniert:

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
65
66
67
68
69
70
71
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren JSON

crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def scrape_zoro_listings(Basis-URL, Seitennummer):
Basis-URL = f"{base_url}&Seite={Seitenzahl}"
Optionen = {
'ajax_wait': "wahr", # Sicherstellen, dass JavaScript-Inhalte geladen werden
'Seite_warten': '5000', # Bei langsamen Seiten 5 Sekunden warten
}
Antwort = crawling_api.get(Basis-URL, Optionen)

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

Produkte = Suppe.Auswahl('Abschnitt [data-za="Produktkartenliste"] > div.search-product-card')
für den PRODUKTE in Produkte:
Marke = Produkt.Wählen Sie eins aus('span.Markenname').text.strip() if produkt.wählen_eins('span.Markenname') sonst ''
Titel = Produkt.Wählen Sie eins aus(„div.Produkttitel“).text.strip() if produkt.wählen_eins(„div.Produkttitel“) sonst ''
Preis = Produkt.Wählen Sie eins aus('div.Preis').text.strip() if produkt.wählen_eins('div.Preis') sonst ''
url = produkt.wählen_sie_eines(„div.Produkttitel a“)['href'] if produkt.wählen_eins(„div.Produkttitel a“) sonst ''
Bild-URL = Produkt.Wählen Sie eine('img[data-za="Produktbild"]')['Quelle'] if produkt.wählen_eins('img[data-za="Produktbild"]') sonst ''

Daten.anhängen({
'Marke': Marke,
‚Titel‘: Titel,
'Preis': Preis,
'URL': f"https://www.zoro.com{URL}",
'Bild-URL': Bild-URL
})

Rückkehr die Datenerfassung
sonst:
drucken(f"Seite konnte nicht abgerufen werden {Seitenzahl}Stand: {Antwort['Kopfzeilen']['pc_status']}")
Rückkehr []

def Alle Seiten auslesen(Basis-URL, max_Seiten=Keine):
alle_daten = []
Seite = 1

während Wahre:
drucken(f"Seite scrapen {Seite}... ")
Seitendaten = scrape_zoro_listings(Basis-URL, Seite)

# Die Schleife wird unterbrochen, wenn von der aktuellen Seite keine Daten zurückgegeben werden
if nicht Seitendaten:
drucken(„Keine weiteren Daten gefunden. Paginierung wird gestoppt.“)
brechen

all_data.extend(Seitendaten)
Seite += 1

# Stoppen, wenn das maximale Seitenlimit erreicht ist
if max_Seiten und Seite > max_Seiten:
drucken(f"Das maximale Limit erreicht von {max_pages} Seiten.")
brechen

Rückkehr alle_daten

def in JSON speichern(Daten, Dateiname='zoro_listings.json'):
mit XNUMXh geöffnet(Dateiname, 'w') as f:
json.dump(Daten, f, Einzug=4)
drucken(f"Daten gespeichert in {Dateiname}")

if __name__ == "__hauptsächlich__":
Basis-URL = 'https://www.zoro.com/search?q=tool+box'
scraped_data = scrape_all_pages(Basis-URL, 1)
save_to_json(gescrapte_Daten)

Dieser Scraper extrahiert effizient Zoro-Suchlistendaten, übernimmt die Paginierung und speichert die Ergebnisse zur weiteren Analyse in einer strukturierten JSON-Datei.

Beispielausgabe:

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
[
{
"Marke": „Apex-Werkzeuggruppe“,
„Titel“: "Werkzeugkasten mit 3 Schubladen",
"Preis": „Produktpreis: 149.99 $/Stück“,
"URL": „https://www.zoro.com/apex-tool-group-3-drawer-tool-box-83151/i/G6893443/“,
"Bild URL": „https://www.zoro.com/static/cms/product/prev/Integrated Supply Network LLC_KDT83151xx1200Wx1200Hxx305c78.jpg“
},
{
"Marke": "K-Tool International",
„Titel“: "Werkzeugkasten, 10 Schubladen, schwarz, 41 Zoll B",
"Preis": „Produktpreis: 1,400.99 $/Stück“,
"URL": „https://www.zoro.com/k-tool-international-tool-box-10-drawer-black-41-in-w-kti75132/i/G406006122/“,
"Bild URL": „https://www.zoro.com/static/cms/product/prev/Integrated Supply Network LLC_KTI75132xxmediaxx01xx4b250d.jpeg“
},
{
"Marke": "Proto",
„Titel“: "Allzweck-Werkzeugkasten mit Doppelverriegelung und Ablage, Stahl, Rot, 20" B x 8.5" T x 9.5" H",
"Preis": „Produktpreis: 51.99 $/Stück“,
"URL": "https://www.zoro.com/proto-general-purpose-double-latch-tool-box-with-tray-steel-red-20-w-x-85-d-x-95-h-j9975r/i/G0067825/",
"Bild URL": „https://www.zoro.com/static/cms/product/prev/Z1o8_0mcpEx-.JPG“
},
{
"Marke": „Dewalt“,
„Titel“: "Werkzeugkasten auf Rollen, Kunststoff, schwarz, 28 Zoll B x 12 1/2 Zoll T x 12 Zoll H",
"Preis": „Produktpreis: 43.19 $/Stück“,
"URL": "https://www.zoro.com/dewalt-rolling-tool-box-plastic-black-28-in-w-x-12-12-in-d-x-12-in-h-dwst28100/i/G3778857/",
"Bild URL": „https://www.zoro.com/static/cms/product/prev/Z1wK0zqcpEx-.JPG“
},
{
"Marke": „Milwaukee-Werkzeug“,
„Titel“: "PACKOUT XL Werkzeugkasten, schlagfest, Polymer, Schwarz/Rot, 22 Zoll B x 16 Zoll T x 19 Zoll H",
"Preis": „Produktpreis: 119.00 $/Stück“,
"URL": "https://www.zoro.com/milwaukee-tool-packout-xl-tool-box-impact-resistant-polymer-blackred-22-in-w-x-16-in-d-x-19-in-h-48-22-8429/i/G001272021/",
"Bild URL": „https://www.zoro.com/static/cms/product/prev/Z3pAyumcpEx_.JPG“
},
.... mehr
]

Scraping von Zoro-Produktseiten

Durch das Scraping von Produktseiten auf Zoro können Sie detaillierte Informationen zu einzelnen Produkten extrahieren, z. B. Beschreibungen, Spezifikationen und Bewertungen. Lassen Sie uns diesen Abschnitt in umsetzbare Schritte unterteilen.

Die Struktur von Produktseiten verstehen

Um Daten effektiv zu scrapen, verwenden Sie die Entwicklertools des Browsers, um Schlüsselelemente zu prüfen und ihre eindeutigen CSS-Selektoren zu identifizieren.

Ein Screenshot der Zoro-Produktseite – HTML-Inspektionsstruktur

Wichtige Elemente, auf die Sie achten sollten:

  • Produkttitel: <h1> tag mit data-za="product-name".
  • Preis: <div> tag mit data-za="product-price".
  • Beschreibung: <div> mit Klasse product-description, verschachtelt <div> mit Klasse description-text.
  • Spezifikationen : Zeilen in einem <table> . <div class="product-details-info">, mit zwei <td> Elemente pro Zeile.
  • Produktbilder: <img> Tags in <div class="product-images">, mit Klasse product-image.

Extrahieren wichtiger Details aus Produkten

Unten finden Sie eine Python-Funktion zum Scrapen der Details einer Produktseite:

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
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren re

# Crawlbase API initialisieren
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

# Funktion zum Scrapen von Produktseitendetails
def Produktseite scrapen(Produkt-URL):
Optionen = {
'ajax_wait': "wahr",
'Seite_warten': '5000',
}
Antwort = crawling_api.get(Produkt-URL, Optionen)

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

Titel = {re.sub(r'\s+', '', Suppe.Wählen Sie eine('h1[data-za="Produktname"]').text.strip())} if Suppe.Wähle eine('h1[data-za="Produktname"]') sonst ''
Preis = Suppe.select_one('div[data-za="Produktpreis"] span.Währung').text.strip() if Suppe.Wähle eine('div[data-za="Produktpreis"] span.Währung') sonst ''
Beschreibung = re.sub(r'\s+', '', Suppe.Wählen Sie eine(„div.Produktbeschreibung div.Beschreibungstext“).text.strip()) if Suppe.Wähle eine(„div.Produktbeschreibung div.Beschreibungstext“) sonst ''
Spezifikationen = {re.sub(r'\s+', '', Zeile.find_all('td')[0].text.strip()): re.sub(r'\s+', '',row.find_all('td')[1].text.strip()) für den Reihe in Suppe.Auswählen(„div.Produktdetails-Info-Tabelle tr“) if len(Zeile.alles_finden('td')) == 2}
Bild-URLs = [Bild['Quelle'] für den img in Suppe.Auswählen(„div.Produktbilder img.Produktbild“) if 'Quelle' in Bild.attrs]

Rückkehr {
‚Titel‘: Titel,
'Preis': Preis,
'Bezeichnung': Beschreibung,
'Spezifikationen': Spezifikationen,
'Bild-URLs': Bild-URLs,
'URL': Produkt-URL
}
sonst:
drucken(f"Produktseite konnte nicht abgerufen werden: {Produkt-URL}Stand: {Antwort['Kopfzeilen']['pc_status']}")
Rückkehr {}

Produktdaten in einer JSON-Datei speichern

Speichern Sie die extrahierten Produktdetails zur späteren Verwendung in einer JSON-Datei:

1
2
3
4
5
6
importieren JSON

def Produktdaten speichern(Daten, Dateiname='zoro_products.json'):
mit XNUMXh geöffnet(Dateiname, 'w') as f:
json.dump(Daten, f, Einzug=4)
drucken(f"Produktdaten gespeichert in {Dateiname}")

Vollständiges Codebeispiel

Hier ist der vollständige Code zum Scrapen mehrerer Produktseiten und Speichern der Daten in einer JSON-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
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren JSON
importieren re

crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def Produktseite scrapen(Produkt-URL):
Optionen = {
'ajax_wait': "wahr",
'Seite_warten': '5000',
}
Antwort = crawling_api.get(Produkt-URL, Optionen)

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

Titel = {re.sub(r'\s+', '', Suppe.Wählen Sie eine('h1[data-za="Produktname"]').text.strip())} if Suppe.Wähle eine('h1[data-za="Produktname"]') sonst ''
Preis = Suppe.select_one('div[data-za="Produktpreis"] span.Währung').text.strip() if Suppe.Wähle eine('div[data-za="Produktpreis"] span.Währung') sonst ''
Beschreibung = re.sub(r'\s+', '', Suppe.Wählen Sie eine(„div.Produktbeschreibung div.Beschreibungstext“).text.strip()) if Suppe.Wähle eine(„div.Produktbeschreibung div.Beschreibungstext“) sonst ''
Spezifikationen = {re.sub(r'\s+', '', Zeile.find_all('td')[0].text.strip()): re.sub(r'\s+', '',row.find_all('td')[1].text.strip()) für den Reihe in Suppe.Auswählen(„div.Produktdetails-Info-Tabelle tr“) if len(Zeile.alles_finden('td')) == 2}
Bild-URLs = [Bild['Quelle'] für den img in Suppe.Auswählen(„div.Produktbilder img.Produktbild“) if 'Quelle' in Bild.attrs]

Rückkehr {
‚Titel‘: Titel,
'Preis': Preis,
'Bezeichnung': Beschreibung,
'Spezifikationen': Spezifikationen,
'Bild-URLs': Bild-URLs,
'URL': Produkt-URL
}
sonst:
drucken(f"Produktseite konnte nicht abgerufen werden: {Produkt-URL}Stand: {Antwort['Kopfzeilen']['pc_status']}")
Rückkehr {}

def Produktdaten speichern(Daten, Dateiname='zoro_products.json'):
mit XNUMXh geöffnet(Dateiname, 'w') as f:
json.dump(Daten, f, Einzug=4)
drucken(f"Produktdaten gespeichert in {Dateiname}")

if __name__ == "__hauptsächlich__":
Produkt-URLs = [
„https://www.zoro.com/apex-tool-group-3-drawer-tool-box-83151/i/G6893443/“,
„https://www.zoro.com/k-tool-international-tool-box-10-drawer-black-41-in-w-kti75132/i/G406006122/“,
"https://www.zoro.com/proto-general-purpose-double-latch-tool-box-with-tray-steel-red-20-w-x-85-d-x-95-h-j9975r/i/G0067825/"
]

alle_produkt_daten = []
für den URL in Produkt-URLs:
drucken(f"Abschabeprodukt: {URL}")
Produktdaten = Produktseite scrapen(URL)
if Produktdaten:
alle_produktdaten.anhängen(produktdaten)

Produktdaten speichern (alle Produktdaten)

Dieses Skript liest Produktdaten von mehreren Zoro-Produktseiten ein, extrahiert relevante Informationen und speichert sie in einer strukturierten JSON-Datei.

Beispielausgabe:

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
[
{
„Titel“: "Werkzeugkasten mit 3 Schubladen",
"Preis": "$",
„Beschreibung“: "Werkzeugkasten mit 3 Schubladen",
"Spezifikationen": {
"Artikel": "Werkzeugkasten",
"Farbe": "Schwarz",
"Eigenschaften": "3-Schubladen",
"Beinhaltet": "Drei Schubladen"
},
"Bild-URLs": [
"https://www.zoro.com/static/cms/product/large/Integrated%20Supply%20Network%20LLC_KDT83151xx1200Wx1200Hxx305c78.jpg"
],
"URL": „https://www.zoro.com/apex-tool-group-3-drawer-tool-box-83151/i/G6893443/“
},
{
„Titel“: "Werkzeugkasten, 10 Schubladen, schwarz, 41 Zoll B",
"Preis": "$",
„Beschreibung“: "Gesamtkapazität: 1000 lb; 10 Schubladen mit Rollenführungen, Werkzeugkasten mit zwei Fächern; Schubladengriffe aus eloxiertem Aluminium; Schiebestange; Integrierte UL-Steckdosenleiste; 10-teiliges EVA-Liner-Set; 5 x 2 Zoll große Lenkrollen, 2 Stück mit Bremse, schwarze Halterungen, schwarzes Rad; Langlebige Pulverbeschichtung; Komplett montiert",
"Spezifikationen": {
"Breite": "41 in",
"Artikel": "Werkzeugkasten",
"Anzahl der Schubladen": "10",
"Farbe": "Schwarz",
"Beinhaltet": "41" Premium-Werkzeugkasten mit 10 Schubladen und Doppelfach, 1,000 Pfund (Mattschwarz)",
"Eigenschaften": "Doppelbucht"
},
"Bild-URLs": [
"https://www.zoro.com/static/cms/product/large/Integrated%20Supply%20Network%20LLC_KTI75132xxmediaxx01xx4b250d.jpeg"
],
"URL": „https://www.zoro.com/k-tool-international-tool-box-10-drawer-black-41-in-w-kti75132/i/G406006122/“
},
{
„Titel“: "Allzweck-Werkzeugkasten mit Doppelverriegelung und Ablage, Stahl, Rot, 20" B x 8.5" T x 9.5" H",
"Preis": "$",
„Beschreibung“: "Der PROTO - J9975R ist ein robuster Werkzeugkasten aus Stahl, der für die sichere und geordnete Aufbewahrung Ihrer Werkzeuge konzipiert ist. Dieser individuelle Werkzeugkasten bietet ein großzügiges Fassungsvermögen von 2,133 Kubikzoll, sodass Sie eine Vielzahl von Werkzeugen und Baumaterialien unterbringen können. Der Werkzeugkasten verfügt über ein mit Vorhängeschloss abschließbares Schließsystem für zusätzliche Sicherheit gegen unbefugten Zugriff. Er ist mit einem klappbaren oberen Griff ausgestattet, der das Tragen und den Zugriff erleichtert. Hauptmerkmale:\u2022 Hergestellt aus langlebigem Stahlmaterial, das seine Langlebigkeit erhöht.\u2022 Bietet reichlich Stauraum mit einem beeindruckenden Fassungsvermögen von 2,133 Kubikzoll.\u2022 Ausgestattet mit zwei Fächern für eine bessere Organisation Ihrer Werkzeuge.\u2022 Verfügt über eine herausnehmbare Stahltrageschale, die die Benutzerfreundlichkeit und den Komfort verbessert.\u2022 Entworfen mit einem klappbaren oberen Griff zum einfachen Tragen und Zugriff auf den Werkzeugkasten.\u2022 Enthält eine herausnehmbare Trageschale, die Flexibilität bei der Aufbewahrungsaufteilung bietet.",
"Spezifikationen": {
"Breite": "20 in",
"Tiefe": "8-1/2 Zoll",
"Höhe": "9-1/2 Zoll",
„Gesamtbreite“: "20 in",
„Gesamttiefe“: "8 1/2 Zoll",
"Innenbreite": "19 3/4 Zoll",
„Nominelle Außenbreite“: "20 in",
"Innenhöhe": "9 1/4 Zoll",
„Nominelle Außenhöhe“: "9 in",
"Gesamthöhe": "9 1/2 Zoll",
„Nominelle Außentiefe“: "8 in",
„Innere Tiefe“: "8 1/4 Zoll",
"Innenmaße": "19 3/4 Zoll B x 8 1/4 Zoll T x 9 1/4 Zoll H",
"Innere Tiefe": "8 1/4 Zoll",
"Innenhöhe": "9 1/4 Zoll",
"Innenbreite": "19 3/4 Zoll",
"Artikel": "Werkzeugkasten",
"Material": "Stahl",
"Farbe": "Rot",
"Eigenschaften": „Abnehmbare Trageschale aus Stahl“,
"Beinhaltet": "Abnehmbares Tragetablett",
"Grifftyp": "Klappgriff oben",
"Griffdesign": "Faltverdeck",
„Speicherkapazität“: „2,133 Kubikzoll“,
"Stückzahl": "1",
„Produktgruppierung für tragbare Werkzeugkästen“: „Tragbare Werkzeugkisten“,
"Schubladenführungen": "Keiner",
"Anzahl der Schubladen": "0",
"Verschlusssystem": "Vorhängeschloss",
"Anzahl der Fächer": "1",
"Gewichtskapazität": "40 Pfund",
"Anzahl der Griffe": "1",
„Primäres Werkzeugkastenmaterial“: "Stahl",
„Primäre Werkzeugkastenfarbe“: "Rot",
"Fertig": "Pulverbeschichtet",
"Anzahl der Fächer": "2",
"Externes Material": "Stahl",
"Verschlussart": "Verriegeln",
"Stapelbar": „Nicht stapelbar“,
"Körperlackierung": "Pulverbeschichtet",
"Körpermaß": „14ga“,
"Anzahl der enthaltenen Schlüssel": "0",
"Aufbau": "Individuelle Werkzeugkiste",
„Griffgriff-Stil“: "Metall",
"Inklusive Schlüssel": "Schlüssel nicht im Lieferumfang enthalten",
„Gesamttragfähigkeit“: "40 Pfund",
„Tragfähigkeit pro Schublade“: "10 Pfund",
"Inklusive Schubladen": "Schubladen nicht im Lieferumfang enthalten",
"Anzahl der Boxen": "1",
"Inklusive Rollen": "Rollen nicht im Lieferumfang enthalten",
„Gesamtspeicherkapazität“: „2,133 Kubikzoll“,
"Anzahl der Teiler": "1"
},
"Bild-URLs": [
„https://www.zoro.com/static/cms/product/large/Z1o8_0mcpEx-.JPG“,
„https://www.zoro.com/static/cms/product/full/Z1o8_0mcpEx_.JPG“
],
"URL": "https://www.zoro.com/proto-general-purpose-double-latch-tool-box-with-tray-steel-red-20-w-x-85-d-x-95-h-j9975r/i/G0067825/"
}
]

Abschließende Überlegungen

Das Scraping von Zoro.com-Websitedaten kann für Unternehmen, Forscher und Entwickler, die Produkttrends analysieren, Preise vergleichen oder Tools zur Bestandsautomatisierung erstellen möchten, ein völliger Game Changer sein. Mit modernen Tools wie dem Crawlbase Crawling API macht die Handhabung von mit JavaScript gerenderten Inhalten und die Seitennummerierung zum Kinderspiel.

Befolgen Sie die Schritte in diesem Beitrag, und Sie können Daten aus Zoros Suchlisten und Produktseiten extrahieren und die Ergebnisse in einem strukturierten Format wie JSON speichern. Gehen Sie immer verantwortungsvoll mit diesen Daten um und befolgen Sie die Nutzungsbedingungen der Website.

Wenn Sie von anderen E-Commerce-Plattformen scrapen möchten, sehen Sie sich diese anderen Anleitungen an.

📜 Wie man Amazon scrapt
📜 Wie man Walmart scrapt
📜 So scrapen Sie AliExpress
📜 Wie man Zalando scrapt
📜 So scrapen Sie Einzelhandelsdaten von Farfetch

Hotline | KolbenKraft Deutschland Support wenn Sie Fragen haben. Viel Spaß beim Scrapen!

Häufig gestellte Fragen (FAQs)

Web Scraping ist grundsätzlich legal, sofern es aus ethischen Gründen und im Rahmen der Zoro-Nutzungsbedingungen erfolgt. Überprüfen Sie immer deren Richtlinien und scrapen Sie keine sensiblen oder vertraulichen Daten.

F: Welche Werkzeuge benötige ich, um Zoro effektiv zu scrapen?

Um Zoro zu scrapen, benötigen Sie Python, BeautifulSoup für die HTML-Analyse und die Crawlbase Crawling API um mit JavaScript gerenderte Inhalte und Seitennummerierung zu handhaben.

F: Wie kann ich die Scraped-Daten für die zukünftige Verwendung speichern?

Die Scraped-Daten können je nach Projekt in Formaten wie JSON, CSV oder einer Datenbank gespeichert werden. JSON eignet sich am besten für strukturierte Daten und lässt sich leicht in andere Apps integrieren.