So scrapen Sie effektiv Mittagsdaten

Noon ist eine der größten E-Commerce-Plattformen im Nahen Osten mit Millionen von Kunden in den Vereinigten Arabischen Emiraten, Saudi-Arabien und Ägypten. Noon verfügt über einen riesigen Produktkatalog und führt täglich Tausende von Transaktionen durch. Das Scraping von Noon-Daten hilft Unternehmen dabei, Preise, Wettbewerber und Markteinblicke zu verfolgen.

Aber das Scraping von Noon ist schwierig. Die Website verfügt über dynamische Inhalte, JavaScript-basierte Elemente und Anti-Bot-Maßnahmen, die herkömmliche Scraping-Methoden blockieren können. Wir werden Crawlbase Crawling API um Suchergebnisse und Produktdetails zu extrahieren und gleichzeitig diese Herausforderungen zu bewältigen.

Dieses Tutorial zeigt Ihnen anhand schrittweiser Beispiele zur strukturierten Datenextraktion, wie Sie mit Python Noon-Daten scrapen.

Lasst uns beginnen!

Inhaltsverzeichnis

1. Warum Mittagsdaten scrapen?
2. Wichtige Datenpunkte zum Extrahieren aus Noon
3. Herausforderungen beim Scraping Noon
4. Einrichten Ihrer Python-Umgebung

• Installieren von Python und erforderlichen Bibliotheken
• Auswahl einer IDE

5. Ergebnisse der Noon-Suche auslesen

• Untersuchen des HTML auf CSS-Selektoren
• Schreiben des Noon Search Listings Scrapers
• Umgang mit Paginierung
• Speichern von Daten in einer CSV-Datei
• Vollständiges Codebeispiel

6. Scraping von Noon-Produktseiten

• Untersuchen des HTML auf CSS-Selektoren
• Schreiben des Produktseiten-Scrapers
• Speichern von Daten in einer CSV-Datei
• Vollständiges Codebeispiel

7. Abschließende Überlegungen
8. Häufig gestellte Fragen

Warum Mittagsdaten scrapen?

Mit einem umfangreichen Produktkatalog, der die Bereiche Elektronik, Mode, Kosmetik, Lebensmittel und mehr abdeckt, ist das Unternehmen ein wichtiger Akteur in der E-Commerce-Branche der Region.

Aus diesem Grund scrapen Leute Noon:

• Preisverfolgung: Beobachten Sie die Preise der Konkurrenz und passen Sie Ihre Preisstrategie an.
• Produktverfügbarkeit: Behalten Sie Lagerbestände und Nachfragetrends im Auge.
• Customer Insights: Analysieren Sie Bewertungen, Ratings und Produktbeschreibungen, um die Verbraucherpräferenzen zu verstehen.
• SEO- und Marketingstrategien: Erhalten Sie Produktmetadaten und optimieren Sie die Sichtbarkeit Ihrer Einträge.
• Überwachung von Verkäufen und Rabatten: Verfolgen Sie laufende Werbeaktionen und Sonderangebote.

Wichtige Datenpunkte zum Extrahieren aus Noon

Noon bietet Millionen von Produkten in verschiedenen Kategorien an. Um das Beste aus Scraping herauszuholen, konzentriert sich Noon auf die wichtigsten Datenpunkte, um Ihre Geschäftsentscheidungen zu unterstützen und einen Wettbewerbsvorteil zu erzielen. Das folgende Bild zeigt einige der Datenpunkte, auf die Sie sich konzentrieren sollten.

Herausforderungen beim Scraping Noon

Das Scraping von Noon kann gut sein, es kann jedoch zu einigen Herausforderungen kommen. Hier sind einige häufige Herausforderungen beim Scraping von Noon und ihre Lösungen:

• Dynamischer Inhalt (JavaScript-Rendering): Noon verwendet JavaScript, um dynamische Inhalte zu laden, sodass das Scraping schwieriger ist. Ohne geeignete Tools werden die Inhalte möglicherweise gar nicht oder falsch geladen, was zu unvollständigen oder falschen Daten führt.

• Die Lösung : Verwenden Sie die Crawlbase Crawling API, das die JavaScript-Wiedergabe nahtlos übernimmt, und Sie erhalten den vollständigen Seiteninhalt, einschließlich dynamisch geladener Elemente wie Produktdetails und Preise.

• Anti-Bot-Maßnahmen: Websites wie Noon implementieren Anti-Bot-Technologien wie CAPTCHAs und Rate-Limiting, um automatisiertes Scraping zu verhindern.

• Lösung: Die Crawlbase Crawling API umgeht diese Schutzmaßnahmen durch die Rotation von IP-Adressen, das Lösen von CAPTCHAs und die Nachahmung menschlichen Surfverhaltens, sodass Sie beim Scraping nicht blockiert werden.

• Komplexe Paginierung: Die Navigation durch Suchergebnisse und Produktseiten umfasst mehrere Seiten mit Daten. Die korrekte Handhabung der Seitennummerierung ist wichtig, damit Sie nichts übersehen.

• Die Lösung : Crawlbase Crawling API bietet verschiedene Parameter zur Handhabung der Seitennummerierung, sodass Sie alle Seiten mit Suchergebnissen oder Produktlisten durchsuchen können, ohne manuell durch sie navigieren zu müssen.

• Rechtliche und ethische Bedenken: Das Scraping jeder Website, einschließlich Noon, muss gemäß den rechtlichen und ethischen Richtlinien erfolgen. Sie müssen die robots.txt-Datei der Website respektieren, die Scraping-Häufigkeit begrenzen und das Scraping vertraulicher Informationen vermeiden.

• Die Lösung : Befolgen Sie immer die Best Practices für verantwortungsvolles Scraping, z. B. die Verwendung geeigneter Verzögerungsintervalle und die Anonymisierung Ihrer Anfragen.

Indem Sie die richtigen Tools wie Crawlbase verwenden und ethische Scraping-Praktiken befolgen, können Sie diese Herausforderungen überwinden und Noon effizient scrapen.

Einrichten Ihrer Python-Umgebung

Bevor Sie mit dem Scraping von Noon-Daten beginnen, müssen Sie Ihre Umgebung einrichten. Dazu gehört die Installation von Python, der erforderlichen Bibliotheken und die Auswahl der richtigen IDE zum Codieren.

Installieren von Python und erforderlichen Bibliotheken

Wenn Sie Python nicht installiert haben, laden Sie die neueste Version herunter von python.org und folgen Sie den Installationsanweisungen für Ihr Betriebssystem.

Als nächstes installieren Sie die erforderlichen Bibliotheken, indem Sie Folgendes ausführen:

pip installieren crawlbase beautifulsoup4 pandas

• Crawlbase – Umgeht Anti-Bot-Schutzmaßnahmen und durchsucht Seiten mit großem JavaScript-Aufkommen.
• BeautifulSuppe – Extrahiert strukturierte Daten aus HTML.
• Pandas – Verarbeitet und speichert Daten im CSV-Format.

Auswahl einer IDE zum Scraping

Die Wahl der richtigen integrierten Entwicklungsumgebung (IDE) erleichtert das Scraping. Hier sind einige gute Optionen:

• VS-Code – Leicht und funktionsreich mit großartiger Python-Unterstützung.
• PyCharm – Leistungsstarke Debugging- und Automatisierungsfunktionen.
• Jupyter Notizbuch – Ideal für interaktives Scraping und schnelle Datenanalyse.

Nachdem Sie Python installiert, die Bibliotheken eingerichtet und die IDE bereit haben, können Sie nun mit dem Scraping von Noon-Daten beginnen.

Ergebnisse der Noon-Suche auslesen

Durch das Scraping der Suchergebnisse von Noon erhalten Sie Produktnamen, Preise, Bewertungen und URLs. Diese Daten sind nützlich für Wettbewerbsanalysen, Preisüberwachung und Marktforschung. In diesem Abschnitt führen wir Sie durch den Prozess des Scrapings der Suchergebnisse von Noon, der Handhabung der Paginierung und der Speicherung der Daten in einer CSV-Datei.

Untersuchen des HTML auf CSS-Selektoren

Bevor wir mit dem Schreiben des Scrapers beginnen, müssen wir die HTML-Struktur der Suchergebnisseite von Noon überprüfen. Auf diese Weise können wir die CSS-Selektoren finden, um die Produktdetails zu extrahieren.

1. Gehen Sie zu Mittag.com und suchen Sie nach einem Produkt (z. B. „Smartphones“).
2. Klicken Sie mit der rechten Maustaste auf ein beliebiges Produkt und wählen Sie „Untersuchen“ oder „Element untersuchen“ in den Chrome Developer Tools.

3. Identifizieren Sie die folgenden wichtigen HTML-Elemente:

• Produkttitel: Gefunden im <div data-qa="product-name"> -Tag.
• Preis: Gefunden im <strong class="amount"> -Tag.
• Währung: Gefunden im <span class="currency"> -Tag.
• Bewertungen: Gefunden im <div class="dGLdNc"> -Tag.
• Produkt-URL: Gefunden im href Attribut des <a> -Tag.

Sobald Sie die relevanten Elemente und ihre CSS-Klassen oder IDs identifiziert haben, können Sie mit dem Schreiben des Scrapers fortfahren.

Schreiben des Noon Search Listings Scrapers

Nachdem wir nun die HTML-Struktur überprüft haben, können wir ein Python-Skript schreiben, um die Produktdaten von Noon abzurufen. Wir verwenden Crawlbase Crawling API zum Umgehen von Anti-Bot-Maßnahmen und BeautifulSoup zum Parsen des HTML.

von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe

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

def scrape_noon_search(Abfrage, Seite):
    """Suchergebnisse von Noon scrapen."""
    URL = f"https://www.noon.com/uae-en/search/?q={Abfrage}&Seite={Seite}"
    Optionen = {'ajax_wait': "wahr", 'Seite_warten': '5000'}

    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden {Seite}.")
        Rückkehr Keine

def Produktdaten extrahieren(html):
    """Produktdetails aus den Noon-Suchergebnissen extrahieren."""
    Suppe = Schöne Suppe (html, 'html.parser')
    Produkte = []

    für den Artikel in Suppe.Auswählen(„div.grid > span.productContainer“):
        Titel = Element.Wählen Sie eins aus('div[data-qa="Produktname"]').text.strip() if Element.Wählen Sie eins aus('div[data-qa="Produktname"]') sonst ''
        Preis = Artikel.Wählen Sie einen Artikel aus(„starker Betrag“).text.strip() if Element.Wählen Sie eins aus(„starker Betrag“) sonst ''
        Währung = Artikel.Wählen Sie einen aus(„span.währung“).text.strip() if Element.Wählen Sie eins aus(„span.währung“) sonst ''
        Bewertung = Artikel.Wählen Sie einen aus(„div.dGLdNc“).text.strip() if Element.Wählen Sie eins aus(„div.dGLdNc“) sonst ''
        Link = f"https://www.noon.com{item.select_one('A')['href']}" if Element.Wählen Sie eins aus('A') sonst ''

        if Titel und Preis:
            Produkte.anhängen({
                'Titel': Titel,
                'Preis': Preis,
                'Währung': Währung,
                'Bewertung': Bewertung,
                'URL': Verknüpfung
            })

    Rückkehr Produkte

Wir initialisieren zunächst die CrawlingAPI-Klasse mit einem Token zur Authentifizierung. scrape_noon_search Funktion ruft das HTML einer Suchergebnisseite von Noon basierend auf einer Abfrage und Seitenzahl ab und übernimmt das Laden von AJAX-Inhalten. Die extract_product_data Die Funktion analysiert das HTML mithilfe von BeautifulSoup und extrahiert Details wie Produkttitel, Preise, Bewertungen und URLs. Anschließend gibt sie diese Daten in einer strukturierten Liste von Wörterbüchern zurück.

Umgang mit Paginierung

Die Suchergebnisse von Noon erstrecken sich über mehrere Seiten. Um alle Daten abzurufen, müssen wir die Seitennummerierung vornehmen und jede Seite durchlaufen. So können wir das machen:

def Alle Seiten auslesen(Abfrage, max_pages):
    """Mehrere Seiten mit Suchergebnissen durchsehen."""
    alle_produkte = []

    für den Seite in Angebot(1, max_Seiten + 1):
        drucken(f"Seite scrapen {Seite}... ")
        html = scrape_noon_search(Abfrage, Seite)

        if html:
            Produkte = Produktdaten extrahieren (html)
            if nicht Produkte:
                drucken(„Keine weiteren Ergebnisse gefunden. Wird gestoppt.“)
                brechen
            alle_produkte.erweitern(Produkte)
        sonst:
            brechen

    Rückkehr alle_produkte

Diese Funktion durchläuft die angegebene Seitenzahl und ruft und extrahiert Produktdaten, bis alle Seiten verarbeitet sind.

Speichern von Daten in einer CSV-Datei

Nachdem wir die Produktdetails extrahiert haben, müssen wir die Daten in einem strukturierten Format speichern. Das gebräuchlichste und am einfachsten zu handhabende Format ist CSV. Unten finden Sie den Code zum Speichern der Scraped-Daten:

importieren csv

def als CSV speichern(Daten, Dateiname):
    """Speichern Sie die extrahierten Daten in einer CSV-Datei."""
    Schlüssel = Daten[0].Schlüssel() if die Datenerfassung sonst ['Titel', 'Preis', 'Bewertung', 'URL']

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

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

Diese Funktion speichert die Produktliste als CSV-Datei, sodass sie einfach analysiert oder in andere Tools importiert werden kann.

Vollständiges Codebeispiel

Hier ist das vollständige Python-Skript zum Scrapen der Noon-Suchergebnisse, zur Handhabung der Paginierung und zum Speichern der Daten in einer CSV-Datei:

von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe
importieren csv

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

def scrape_noon_search(Abfrage, Seite):
    """Produktlisten aus den Noon-Suchergebnissen extrahieren."""
    URL = f"https://www.noon.com/uae-en/search/?q={Abfrage}&Seite={Seite}"
    Optionen = {'ajax_wait': "wahr", 'Seite_warten': '5000'}

    Antwort = crawling_api.get(URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden {Seite}.")
        Rückkehr Keine

def Produktdaten extrahieren(html):
    """Produktdetails aus den Noon-Suchergebnissen extrahieren."""
    Suppe = Schöne Suppe (html, 'html.parser')
    Produkte = []

    für den Artikel in Suppe.Auswählen(„div.grid > span.productContainer“):
        Titel = Element.Wählen Sie eins aus('div[data-qa="Produktname"]').text.strip() if Element.Wählen Sie eins aus('div[data-qa="Produktname"]') sonst ''
        Preis = Artikel.Wählen Sie einen Artikel aus(„starker Betrag“).text.strip() if Element.Wählen Sie eins aus(„starker Betrag“) sonst ''
        Währung = Artikel.Wählen Sie einen aus(„span.währung“).text.strip() if Element.Wählen Sie eins aus(„span.währung“) sonst ''
        Bewertung = Artikel.Wählen Sie einen aus(„div.dGLdNc“).text.strip() if Element.Wählen Sie eins aus(„div.dGLdNc“) sonst ''
        Link = f"https://www.noon.com{item.select_one('A')['href']}" if Element.Wählen Sie eins aus('A') sonst ''

        if Titel und Preis:
            Produkte.anhängen({
                'Titel': Titel,
                'Preis': Preis,
                'Währung': Währung,
                'Bewertung': Bewertung,
                'URL': Verknüpfung
            })

    Rückkehr Produkte

def Alle Seiten auslesen(Abfrage, max_pages):
    """Mehrere Seiten mit Suchergebnissen durchsehen."""
    alle_produkte = []

    für den Seite in Angebot(1, max_Seiten + 1):
        drucken(f"Seite scrapen {Seite}... ")
        html = scrape_noon_search(Abfrage, Seite)

        if html:
            Produkte = Produktdaten extrahieren (html)
            if nicht Produkte:
                drucken(„Keine weiteren Ergebnisse gefunden. Wird gestoppt.“)
                brechen
            alle_produkte.erweitern(Produkte)
        sonst:
            brechen

    Rückkehr alle_produkte

def als CSV speichern(Daten, Dateiname):
    """Speichern Sie die extrahierten Daten in einer CSV-Datei."""
    Schlüssel = Daten[0].Schlüssel() if die Datenerfassung sonst ['Titel', 'Preis', 'Bewertung', 'URL']

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

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

def Haupt-†
    """Hauptfunktion zum Ausführen des Scrapers."""
    Abfrage = „Smartphones“  # Ändern Sie den Suchbegriff nach Bedarf
    max_pages = 5  # Legen Sie die Anzahl der zu scrapenden Seiten fest
    alle_Produkte = alle_Seiten_abfragen(Abfrage, max._Seiten)
    speichern_in_csv(alle_produkte, „noon_smartphones.csv“)

if __name__ == "__hauptsächlich__":
    Main()

noon_smartphones.csv Schnappschuss:

Scraping von Noon-Produktseiten

Durch das Scraping von Produktseiten auf Noon erhalten Sie alle Produktdetails, einschließlich Beschreibungen, Spezifikationen und Kundenbewertungen. Diese Daten helfen Unternehmen dabei, ihre Produktlisten und das Kundenverhalten zu optimieren. In diesem Abschnitt gehen wir den Prozess durch, bei dem die HTML-Struktur einer Produktseite überprüft, der Scraper geschrieben und die Daten in einer CSV-Datei gespeichert werden.

Untersuchen des HTML auf CSS-Selektoren

Bevor wir den Scraper schreiben, müssen wir die HTML-Struktur der Produktseite überprüfen, um die richtigen CSS-Selektoren für die Elemente zu identifizieren, die wir scrapen möchten. So geht's:

1. Öffnen Sie mittags eine Produktseite (z. B. eine Smartphone-Seite).
2. Klicken Sie mit der rechten Maustaste auf ein Produktdetails (z. B. Produktname, Preis, Beschreibung) und klicken Sie in den Chrome Developer Tools auf „Untersuchen“.

3. Achten Sie auf Schlüsselelemente wie:

• Produktname: Gefunden im <h1 data-qa^="pdp-name-"> -Tag.
• Preis: Gefunden im <div data-qa="div-price-now"> -Tag.
• Produkt Höhepunkte: Gefunden im <div class="oPZpQ"> -Tag, insbesondere innerhalb einer ungeordneten Liste (<ul>).
• Produktspezifikationen: Gefunden im <div class="dROUvm"> -Tag, innerhalb einer Tabelle <tr> Tags mit <td> Elemente.

Sobald Sie die relevanten Elemente und ihre CSS-Klassen oder IDs identifiziert haben, können Sie mit dem Schreiben des Scrapers fortfahren.

Schreiben des Noon Product Page Scrapers

Schreiben wir nun ein Python-Skript, um die Produktdetails von Noon-Produktseiten mit Crawlbase zu extrahieren. Crawling API und BeautifulSoup.

von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe
importieren re

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

def Produktseite scrapen(Produkt-URL):
    """Produktdetails von einer Noon-Produktseite scrapen."""
    Optionen = {'ajax_wait': "wahr", 'Seite_warten': '3000'}

    Antwort = crawling_api.get(Produkt-URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Produktseite konnte nicht abgerufen werden: {Produkt-URL}.")
        Rückkehr Keine

def Produktdetails extrahieren(html):
    """Extrahieren Sie Details wie Name, Preis, Beschreibung und Bewertungen."""
    Suppe = Schöne Suppe (html, 'html.parser')

    Produkt = {}
    Produkt['Name'] = Suppe.Wähle eine('h1[data-qa^="pdp-name-"]').text.strip() if Suppe.Wähle eine('h1[data-qa^="pdp-name-"]') sonst ''
    Produkt['Preis'] = Suppe.Wähle eine('div[data-qa="div-Preis-jetzt"]').text.strip() if Suppe.Wähle eine('div[data-qa="div-Preis-jetzt"]') sonst ''
    Produkt['Highlights'] = Suppe.Wähle eine('div.oPZpQ ul').text.strip() if Suppe.Wähle eine('div.oPZpQ ul') sonst ''
    Produkt['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.dROUvm-Tabelle tr“) if len(Zeile.alles_finden('td')) == 2}

    Rückkehr PRODUKTE

Speichern von Daten in einer CSV-Datei

Nachdem wir die Produktdetails extrahiert haben, müssen wir diese Informationen zur einfachen Analyse in einem strukturierten Format wie CSV speichern. Hier ist eine einfache Funktion zum Speichern der Scraped-Daten:

importieren csv

def Produktdaten als CSV speichern(Produkte, Dateiname):
    """Produktdetails in einer CSV-Datei speichern."""
    Schlüssel = Produkte[0].Schlüssel() if Produkte sonst ['Name', 'Preis', 'Beschreibung', 'Rezensionen']

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

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

Vollständiges Codebeispiel

Nun kombinieren wir alles zu einem vollständigen Skript. main() Die Funktion sammelt Daten für mehrere Produktseiten und speichert die Ergebnisse in einer CSV-Datei.

von Crawlbase importieren CrawlingAPI
von bs4 importieren BeautifulSuppe
importieren csv
importieren re

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

def Produktseite scrapen(Produkt-URL):
    """Produktdetails von einer Noon-Produktseite scrapen."""
    Optionen = {'ajax_wait': "wahr", 'Seite_warten': '3000'}

    Antwort = crawling_api.get(Produkt-URL, Optionen)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Produktseite konnte nicht abgerufen werden: {Produkt-URL}.")
        Rückkehr Keine

def Produktdetails extrahieren(html):
    """Extrahieren Sie Details wie Name, Preis, Beschreibung und Bewertungen."""
    Suppe = Schöne Suppe (html, 'html.parser')

    Produkt = {}
    Produkt['Name'] = Suppe.Wähle eine('h1[data-qa^="pdp-name-"]').text.strip() if Suppe.Wähle eine('h1[data-qa^="pdp-name-"]') sonst ''
    Produkt['Preis'] = Suppe.Wähle eine('div[data-qa="div-Preis-jetzt"]').text.strip() if Suppe.Wähle eine('div[data-qa="div-Preis-jetzt"]') sonst ''
    Produkt['Highlights'] = Suppe.Wähle eine('div.oPZpQ ul').text.strip() if Suppe.Wähle eine('div.oPZpQ ul') sonst ''
    Produkt['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.dROUvm-Tabelle tr“) if len(Zeile.alles_finden('td')) == 2}

    Rückkehr PRODUKTE

def Produktdaten als CSV speichern(Produkte, Dateiname):
    """Produktdetails in einer CSV-Datei speichern."""
    Schlüssel = Produkte[0].Schlüssel() if Produkte sonst ['Name', 'Preis', 'Beschreibung', 'Rezensionen']

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

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

def Haupt-†
    "Hauptfunktion zum Scrapen von Produktseiten."
    Produkt-URLs = [
        'https://www.noon.com/uae-en/galaxy-s25-ai-dual-sim-silver-shadow-12gb-ram-256gb-5g-middle-east-version/N70140511V/p/?o=e12201b055fa94ee',
        'https://www.noon.com/uae-en/a78-5g-dual-sim-glowing-black-8gb-ram-256gb/N70115717V/p/?o=c99e13ae460efc6b'
    ]  # Liste der zu scrapenden Produkt-URLs

    Produktdaten = []

    für den URL in Produkt-URLs:
        drucken(f"Schaben {URL}... ")
        html = Produktseite scrapen(URL)
        if html:
            Produkt = Produktdetails extrahieren (html)
            product_data.append(Produkt)

    Produktdaten in CSV speichern (Produktdaten, „noon_product_details.csv“)

if __name__ == "__hauptsächlich__":
    Main()

noon_product_details.csv Schnappschuss:

Abschließende Überlegungen

Das Scraping von Noon-Daten eignet sich für Unternehmen hervorragend, um Preise zu verfolgen, Wettbewerber zu analysieren und Produktlisten zu verbessern. Crawlbase Crawling API erleichtert diesen Vorgang durch die Handhabung von JavaScript-Rendering und CAPTCHA-Schutz, sodass Sie vollständige und genaue Daten ohne Hindernisse erhalten.

Mit Python und BeautifulSoup ist das Scraping von Daten aus Noon-Suchergebnissen und Produktseiten ganz einfach. Befolgen Sie ethische Praktiken und richten Sie die richtige Umgebung ein, und Sie verfügen über die Erkenntnisse, die Sie brauchen, um im wettbewerbsintensiven E-Commerce-Spiel die Nase vorn zu behalten.

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
📜 Einfache Schritte zum Extrahieren von Daten aus Zoro

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

Häufig gestellte Fragen

F: Ist Web Scraping legal?

Web Scraping ist legal, solange Sie ethische Richtlinien einhalten. Achten Sie darauf, die robots.txt-Datei der Website zu respektieren, überlasten Sie die Server nicht mit Anfragen und scrapen Sie keine sensiblen Daten. Stellen Sie immer sicher, dass Ihre Scraping-Praktiken den Nutzungsbedingungen der Website und den lokalen Gesetzen entsprechen.

F. Was ist Crawlbase? Crawling API und wie hilft es beim Kratzen am Mittag?

Crawlbase Crawling API ist ein Tool, das beim Scrapen von Websites dabei hilft, gängige Hindernisse wie JavaScript-Rendering und CAPTCHA zu umgehen. Es stellt sicher, dass Sie dynamische Inhalte von Noon scrapen können, ohne blockiert zu werden. Egal, ob Sie Produktseiten oder Suchergebnisse scrapen, Crawlbase kümmert sich um den technischen Teil, sodass Sie problemlos an die Daten gelangen.

F: Kann ich mit dieser Methode Produktpreise und -verfügbarkeit von Noon abrufen?

Ja, Sie können Produktpreise, Verfügbarkeit, Bewertungen und andere wichtige Daten von Noon abrufen. Untersuchen Sie die HTML-Struktur, um CSS-Selektoren zu finden, und verwenden Sie BeautifulSoap für die HTML-Analyse. Verwenden Sie Crawlbase Crawling API zur Handhabung von JS-Rendering und CAPTCHAs.