So scrapen Sie Yelp mit Python im Jahr 2025

In unserer modernen Welt sind Informationen überall. Und wenn es darum geht, herauszufinden, was die Leute denken, Yelp.com steht hoch im Kurs. Es ist nicht nur ein Ort, an dem man gutes Essen oder gute Dienstleistungen findet; es ist eine Goldmine an Meinungen und Bewertungen von alltäglichen Benutzern. Aber wie können wir tief graben und all diese wertvollen Informationen herausbekommen? Hier kommt dieser Blog ins Spiel.

Das Scraping von Yelp mag schwierig erscheinen, aber mit der Leistung von Python, einer benutzerfreundlichen und beliebten Programmiersprache, und der Hilfe der Crawlbase Crawling API, es wird ein Kinderspiel. Gemeinsam lernen wir, wie Yelp aufgebaut ist, wie man seine Daten erfasst (Yelp-Scraper erstellen) und sogar, wie man sie für die zukünftige Verwendung speichert. Egal, ob Sie gerade erst anfangen oder schon ein bisschen gescrapt haben, dieser Leitfaden ist vollgepackt mit einfachen Schritten und cleveren Tipps, um das Beste aus Yelps umfangreichen Daten herauszuholen.

Inhaltsverzeichnis

1. Warum Yelp scrapen?

• Warum ist das Scraping von Yelp-Daten so besonders?

2. Yelp Scraping-Bibliotheken und Tools

• Python zum Web Scraping verwenden Yelp
• Installieren und Einrichten der erforderlichen Bibliotheken
• Auswahl der richtigen Entwicklungs-IDE

4. Crawlbase nutzen Crawling API

• Einführung in Crawlbase und seine Funktionen
• Wie diese API Web Scraping-Aufgaben vereinfacht
• Einen Token für Crawlbase erhalten Crawling API
• Crawlbase Python-Bibliothek

5. So erstellen Sie einen Yelp-Scraper mit Python

• Erstellen der richtigen URL für gezielte Suchen
• So verwenden Sie die Crawlbase Python-Bibliothek zum Abrufen von Webinhalten
• Untersuchen von HTML zum Abrufen von CSS-Selektoren
• HTML mit BeautifulSoup analysieren
• Einbinden der Paginierung: Mehrere Seiten effizient scrapen

6. Speichern und Analysieren von Yelp-Daten

• Speichern von Daten in einer CSV-Datei
• Speichern von Daten in einer SQLite-Datenbank
• So nutzen Sie ausgelesene Yelp-Daten für geschäftliche oder Forschungszwecke

7. Zusammenfassung
8. Häufig gestellte Fragen

Warum Yelp scrapen?

Lassen Sie uns zunächst darüber sprechen, wie nützlich das Scraping von Yelp sein kann. Yelp ist ein Ort, an dem Menschen Bewertungen zu Restaurants, Geschäften und mehr hinterlassen. Aber wussten Sie, dass wir Tools verwenden können, um diese Informationen automatisch zu erfassen? Hier kommt Web Scraping ins Spiel. Es ist eine Möglichkeit, Daten von Websites automatisch zu erfassen. Anstatt Seiten und Seiten mit Inhalten manuell durchzugehen, können Web Scraping-Tools die benötigten Daten extrahieren und so Zeit und Mühe sparen.

Warum ist das Scraping von Yelp-Daten so besonders?

Yelp ist nicht einfach nur eine weitere Website. Es ist eine Plattform, die auf den Stimmen und Erfahrungen der Menschen aufbaut. Jede Rezension, Bewertung und jeder Kommentar auf Yelp stellt die persönliche Erfahrung einer Person mit einem Unternehmen dar. Dieses kollektive Feedback zeichnet ein detailliertes Bild der Verbraucherpräferenzen, des Rufs des Unternehmens und der lokalen Trends. Für Unternehmen kann das Verständnis dieses Feedbacks zu Verbesserungen und besseren Kundenbeziehungen führen. Für Forscher bietet es einen realen Datensatz zur Analyse des Verbraucherverhaltens, der Verbraucherpräferenzen und -stimmungen. Darüber hinaus können Unternehmer die gesammelten Yelp-Daten nutzen, um Marktlücken zu erkennen oder Geschäftsideen zu validieren. Im Wesentlichen sind Yelp-Daten ein Fenster zum Puls lokaler Gemeinschaften und Märkte und damit eine wichtige Ressource für verschiedene Zwecke.

Yelp Scraping-Bibliotheken und Tools

Um Yelp mit Python zu scrapen, ist es entscheidend, die richtigen Tools zur Hand zu haben. Die richtige Einrichtung Ihrer Umgebung gewährleistet ein reibungsloses Scraping-Erlebnis. Lassen Sie uns die ersten Schritte durchgehen, um alles zum Laufen zu bringen.

Python zum Web Scraping verwenden Yelp

Python, bekannt für seine Einfachheit und Vielseitigkeit, ist eine beliebte Wahl für Web Scraping-Aufgaben. Sein reichhaltiges Ökosystem bietet eine Fülle von Bibliotheken, die auf Scraping, Datenextraktion und Analyse zugeschnitten sind. Ein solches leistungsstarkes Tool ist BeautifulSoup4 (oft als BS4 abgekürzt), eine Bibliothek, die beim Extrahieren von Daten aus HTML- und XML-Dateien hilft. Gekoppelt mit Crawlbase, das den Scraping-Prozess vereinfacht, indem es die Feinheiten der Web-Interaktionen berücksichtigt, und Pandas, einer Datenmanipulationsbibliothek, die Scraped-Daten in lesbare Formate strukturiert, verfügen Sie über ein beeindruckendes Toolkit für alle Scraping-Vorhaben.

Installieren und Einrichten der erforderlichen Bibliotheken

Um Ihre Python-Umgebung für Scraping-Aufgaben auszustatten, befolgen Sie diese wichtigen Schritte:

1. Python: Wenn Python noch nicht auf Ihrem System installiert ist, besuchen Sie die offiziellen Website um die entsprechende Version für Ihr Betriebssystem herunterzuladen und zu installieren. Folgen Sie den Installationsanweisungen, um Python zum Laufen zu bringen.
2. Pips: Als Paketmanager von Python erleichtert Pip die Installation und Verwaltung von Bibliotheken. Obwohl viele Python-Installationen mit Pip gebündelt sind, stellen Sie sicher, dass es in Ihrem Setup verfügbar ist.
3. Virtuelle Umgebung: Die Einführung einer virtuellen Umgebung ist ein umsichtiger Ansatz. Sie schafft einen isolierten Raum für Ihr Projekt und stellt sicher, dass Abhängigkeiten von anderen Projekten getrennt bleiben. Um eine virtuelle Umgebung zu initiieren, führen Sie Folgendes aus:

python -m venv meine Umgebung

Öffnen Sie Ihre Eingabeaufforderung oder Ihr Terminal und verwenden Sie einen der folgenden Befehle, um die Umgebung zu aktivieren:

# Windows
myenv\Scripts\activate

# macOS/Linux
Quelle myenv/bin/activate

4. Erforderliche Bibliotheken installieren: Der nächste Schritt ist die Installation der erforderlichen Bibliotheken. Öffnen Sie Ihre Eingabeaufforderung oder Ihr Terminal und führen Sie die folgenden Befehle aus:

pip install beautifulsoup4
pip installieren crawlbase
Pandas installieren
pip matplotlib installieren
pip install scikit-learn

Sobald diese Bibliotheken installiert sind, können Sie mit dem Web Scraping beginnen. Wenn Sie sicherstellen, dass Ihre Umgebung richtig eingerichtet ist, ebnen Sie nicht nur den Weg für effizientes Scraping, sondern stellen auch sicher, dass Sie das volle Potenzial der Ihnen zur Verfügung stehenden Tools nutzen.

Auswahl der richtigen Entwicklungs-IDE

Die Auswahl der richtigen integrierten Entwicklungsumgebung (IDE) kann die Produktivität erheblich steigern. Sie können JavaScript-Code zwar in einem einfachen Texteditor schreiben, aber die Verwendung einer dedizierten IDE bietet Funktionen wie Codevervollständigung, Debugging-Tools und Versionskontrollintegration.

Zu den beliebtesten IDEs für die JavaScript-Entwicklung zählen:

• Visual Studio-Code (VS-Code): VS Code ist ein kostenloser, quelloffener Code-Editor, der von Microsoft entwickelt wurde. Er verfügt über eine aktive Community und bietet eine breite Palette an Erweiterungen für die JavaScript-Entwicklung.
• Websturm: WebStorm ist eine kommerzielle IDE von JetBrains, die für ihre intelligente Codierungsunterstützung und robuste JavaScript-Unterstützung bekannt ist.
• Sublime Text: Sublime Text ist ein leichter und anpassbarer Texteditor, der bei Entwicklern wegen seiner Geschwindigkeit und Erweiterbarkeit beliebt ist.

Wählen Sie eine IDE, die Ihren Vorlieben und Ihrem Arbeitsablauf entspricht.

Crawlbase nutzen Crawling API

Die Crawlbase Crawling API ist eine vielseitige Lösung, die auf die Komplexität des Web Scraping zugeschnitten ist, insbesondere in Szenarien wie Yelp, wo dynamische Inhalte eine geschickte Handhabung erfordern. Diese API ist ein echter Game-Changer, da sie den Zugriff auf Webinhalte vereinfacht, JavaScript rendert und HTML-Inhalte zur Analyse bereitstellt.

Wie diese API Web Scraping-Aufgaben vereinfacht

Im Kern geht es beim Web Scraping darum, Daten von Websites abzurufen. Die wahre Herausforderung besteht jedoch darin, sich durch das Labyrinth der Webstrukturen zu navigieren, potenzielle Fallstricke wie CAPTCHAs zu bewältigen und die Datenintegrität sicherzustellen. Crawlbase vereinfacht diese Aufgaben, indem es Folgendes bietet:

1. JavaScript-Rendering: Viele Websites, darunter auch Airbnb, verlassen sich beim dynamischen Laden von Inhalten stark auf JavaScript. Die Crawlbase-API verarbeitet diese Elemente geschickt und gewährleistet umfassenden Zugriff auf die dynamisch gerenderten Seiten von Airbnb.
2. Vereinfachte Anfragen: Die API abstrahiert die Komplexität der Verwaltung HTTP-Anfragen, Cookies und Sitzungen. So können Sie sich auf die Verfeinerung Ihrer Scraping-Logik konzentrieren, während die API die technischen Nuancen nahtlos übernimmt.
3. Gut strukturierte Daten: Die über die API erhaltenen Daten sind in der Regel gut strukturiert, was die Datenanalyse und Extraktionsprozess. Dadurch wird sichergestellt, dass Sie die gewünschten Preisinformationen effizient von Airbnb abrufen können.
4. Skalierbarkeit: Die Crawlbase Crawling API unterstützt skalierbares Scraping durch effiziente Verwalten mehrerer Anfragen gleichzeitig. Diese Skalierbarkeit ist insbesondere angesichts der vielfältigen und umfangreichen Preisinformationen auf Airbnb von Vorteil.

Note: Die Crawlbase Crawling API bietet Ihnen eine Vielzahl von Parametern, mit denen Sie Ihre Scraping-Anfragen optimieren können. Diese Parameter können an Ihre individuellen Anforderungen angepasst werden, sodass Ihre Web-Scraping-Bemühungen effizienter und präziser werden. Sie können die vollständige Liste der verfügbaren Parameter im API-Dokumentation.

Einen Token für Crawlbase erhalten Crawling API

So greifen Sie auf die Crawlbase zu Crawling APIbenötigen Sie ein API-Token. Hier ist eine einfache Anleitung zum Erhalten eines solchen:

1. Besuchen Sie die Crawlbase-Website: Öffnen Sie Ihren Webbrowser und navigieren Sie zu Crawlbase-Anmeldeseite um den Registrierungsprozess zu starten.
2. Geben Sie Ihre Daten an: Sie werden aufgefordert, Ihre E-Mail-Adresse anzugeben und ein Passwort für Ihr Crawlbase-Konto zu erstellen. Geben Sie die erforderlichen Informationen ein.
3. Verification: Nach dem Absenden Ihrer Daten müssen Sie möglicherweise Ihre E-Mail-Adresse bestätigen. Suchen Sie in Ihrem Posteingang nach einer Bestätigungs-E-Mail von Crawlbase und folgen Sie den bereitgestellten Anweisungen.
4. Login: Sobald Ihr Konto verifiziert ist, kehren Sie zur Crawlbase-Website zurück und melden Sie sich mit Ihren neu erstellten Anmeldeinformationen an.
5. Greifen Sie auf Ihr API-Token zu: Sie benötigen ein API-Token, um die Crawlbase zu verwenden Crawling API. Sie finden Ihre API-Token HIER.

Note: Crawlbase bietet zwei Arten von Token an, einen für statische Websites und einen für dynamische oder JavaScript-basierte Websites. Da wir Yelp scrapen, entscheiden wir uns für den Normal Token. Crawlbase bietet großzügigerweise ein anfängliches Kontingent von 1,000 kostenlosen Anfragen für den Crawling API, was es zu einer ausgezeichneten Wahl für unser Web-Scraping-Projekt macht.

Crawlbase Python-Bibliothek

Die Crawlbase Python-Bibliothek bietet eine einfache Möglichkeit zur Interaktion mit der Crawlbase Crawling API. Sie können diese leichte und abhängigkeitsfreie Python-Klasse als Wrapper für die Crawlbase-API verwenden. Initialisieren Sie zunächst die Crawling API Klasse mit Ihrem Crawlbase-Token. Anschließend können Sie GET-Anfragen stellen, indem Sie die URL angeben, die Sie scrapen möchten, sowie alle gewünschten Optionen, wie benutzerdefinierte Benutzeragenten oder Antwortformate. Sie können beispielsweise eine Webseite scrapen und auf deren Inhalt wie folgt zugreifen:

für Crawlbase importieren CrawlingAPI

# Initialisieren Sie die CrawlingAPI-Klasse
api = CrawlingAPI({ 'Zeichen': 'IHR_CRAWLBASE_TOKEN' })

# Machen Sie eine GET-Anfrage, um eine Webseite zu scrapen
Antwort = api.get(„https://www.example.com“)
if Antwort['Statuscode'] == 200:
    drucken(Antwort['Körper'])

Diese Bibliothek vereinfacht das Abrufen von Webdaten und ist besonders nützlich für Szenarien, in denen dynamische Inhalte, IP-Rotation und andere erweiterte Funktionen der Crawlbase-APIs erforderlich sind.

So erstellen Sie einen Yelp-Scraper mit Python

Yelp bietet eine Fülle von Informationen und die robusten Bibliotheken von Python ermöglichen es uns, diese Daten effizient zu extrahieren. Lassen Sie uns tiefer in die Feinheiten des Abrufens und Analysierens von Yelp-Daten mit Python eintauchen.

Erstellen der richtigen URL für gezielte Suchen

Um bestimmte Daten von Yelp abzurufen, ist es wichtig, die richtige Such-URL zu formulieren. Wenn wir beispielsweise italienische Restaurants in San Francisco durchsuchen möchten, würde unsere Yelp-URL wie folgt aussehen:

https://www.yelp.com/search?find_desc=Italienische+Restaurants&find_loc=San+Francisco%2C+CA

Hier:

• find_desc bestimmt die Geschäftskategorie.
• find_loc gibt den Standort an.

So verwenden Sie die Crawlbase Python-Bibliothek zum Abrufen von Webinhalten

Crawlbase bietet eine effiziente Möglichkeit, Webinhalte abzurufen. Durch die Integration mit Python wird unser Scraping-Vorhaben effizienter. Ein Snippet zum Abrufen von Yelp-Inhalten wäre:

für Crawlbase importieren CrawlingAPI

# Ersetzen Sie „YOUR_CRAWLBASE_TOKEN“ durch Ihr tatsächliches Crawlbase API-Token
api_token = 'IHR_CRAWLBASE_TOKEN'
crawlbase_api = Crawling-API({ 'Zeichen': API-Token })

yelp_url = „https://www.yelp.com/search?find_desc=Italian+Restaurants&find_loc=San+Francisco%2C+CA“

Antwort = crawlbase_api.get(yelp_url)

if Antwort['Statuscode'] == 200:
    # Extrahierter HTML-Inhalt nach dem Dekodieren von Byte-Daten
    html_content = Antwort['Körper'].dekodieren('lateinisch1')
    drucken(HTML-Inhalt)
sonst:
    drucken(f"Anforderung fehlgeschlagen mit Statuscode {Antwort['Statuscode']}: {Antwort['Körper']}")

Um den Yelp-Scraping-Prozess zu starten, folgen Sie diesen einfachen Schritten:

1. Erstellen des Skripts: Beginnen Sie mit der Erstellung einer neuen Python-Skriptdatei. Nennen Sie sie yelp_scraping.py.
2. Fügen Sie den Code ein: Kopieren Sie den zuvor bereitgestellten Code und fügen Sie ihn in Ihr neu erstelltes yelp_scraping.py Datei.
3. Ausführung: Öffnen Sie Ihre Eingabeaufforderung oder Ihr Terminal.
4. Führen Sie das Skript aus: Navigieren Sie zum Verzeichnis mit yelp_scraping.py und führen Sie das Skript mit dem folgenden Befehl aus:

Python yelp_scraping.py

Bei der Ausführung wird der HTML-Inhalt der Seite in Ihrem Terminal angezeigt.

Untersuchen von HTML zum Abrufen von CSS-Selektoren

Nachdem wir den HTML-Inhalt der Listing-Seite gesammelt haben, besteht der nächste Schritt darin, das Layout zu untersuchen und die gewünschten spezifischen Daten zu finden. Hier Web-Entwicklungstools und Browser-Entwicklertools können sehr hilfreich sein. Hier ist eine einfache Anleitung, wie Sie diese Tools verwenden, um Daten von Yelp effizient abzurufen. Überprüfen Sie zunächst das HTML-Layout, um die Bereiche zu identifizieren, die uns interessieren. Suchen Sie dann nach den richtigen CSS-Selektoren, um die benötigten Daten abzurufen.

1. Öffnen Sie die Webseite: Navigieren Sie zur Yelp-Website und landen Sie auf einer Immobilienseite, die Ihr Interesse weckt.
2. Klicken Sie mit der rechten Maustaste und prüfen Sie: Klicken Sie mit der rechten Maustaste auf ein Element, das Sie extrahieren möchten, und wählen Sie im Kontextmenü „Untersuchen“ oder „Element untersuchen“. Dieser mystische Zauberspruch ruft die Entwicklertools des Browsers herauf.
3. Suchen Sie die HTML-Quelle: Innerhalb der Grenzen der Entwicklertools wird der HTML-Quellcode der Webseite seine Geheimnisse preisgeben. Bewegen Sie den Cursor über verschiedene Elemente im HTML-Bedienfeld und erleben Sie, wie die entsprechenden Teile der Webseite wie von Zauberhand aufleuchten.
4. Identifizieren von CSS-Selektoren: Um Daten aus einem bestimmten Element freizugeben, klicken Sie in den Entwicklertools mit der rechten Maustaste darauf und wählen Sie „Kopieren“ > „Selektor kopieren“. Mit diesem eleganten Manöver wird der CSS-Selektor für dieses Element in Ihre Zwischenablage übertragen, damit er für Ihre Web Scraping-Beschwörungen verwendet werden kann.

Sobald Sie über diese Selektoren verfügen, können Sie mit der Strukturierung Ihres Yelp-Scrapers fortfahren, um die erforderlichen Informationen effektiv zu extrahieren.

HTML mit BeautifulSoup analysieren

Nach dem Abrufen des HTML-Rohinhalts besteht die nächste Herausforderung darin, aussagekräftige Daten zu extrahieren. Hier kommt BeautifulSoup ins Spiel. Es handelt sich um eine Python-Bibliothek, die HTML- und XML-Dokumente analysiert und Tools zum Navigieren im analysierten Baum und zum Suchen darin bereitstellt.

Mit BeautifulSoup können Sie bestimmte HTML-Elemente gezielt auswählen und die erforderlichen Informationen extrahieren. In unserem Yelp-Beispiel hilft BeautifulSoup dabei, Restaurantnamen, Bewertungen, Anzahl der Rezensionen, Adressen, Preisspannen und beliebte Artikel aus der abgerufenen Seite zu extrahieren.

für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren JSON

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

def Yelp-Seite abrufen(URL):
    """Den Inhalt der Yelp-Seite abrufen und dekodieren."""
    Antwort = crawling_api.get(URL)
    if Antwort['Statuscode'] == 200:
        Rückkehr Antwort['Körper'].dekodieren('lateinisch1')
    sonst:
        drucken(f"Anforderung fehlgeschlagen mit Statuscode {Antwort['Statuscode']}: {Antwort['Körper']}")
        Rückkehr Keine

def extract_restaurant_info(Listing-Karte):
    """Extrahieren Sie Details aus einer einzelnen Restaurant-Eintragskarte."""
    Name_Element = Listing-Karte.Wählen Sie eine('div[Klasse*="Firmenname"] h3 > span > a')
    Bewertungselement = Listing-Karte.Wählen Sie eine(„div.css-volmcs + div.css-1jq1ouh > span: erstes Kind“)
    Bewertungsanzahlelement = Listing-Karte.Wählen Sie eine aus („div.css-volmcs + div.css-1jq1ouh > span:letztes Kind“)
    beliebte_artikel_elemente = angebotskarte.auswahl('div[Klasse*="Preiskategorie"] div > p > span:erstes-Kind a')
    Preisbereichselement = Listing-Karte.Wählen Sie eine aus ('div[Klasse*="Preiskategorie"] div > p > span:nicht(.css-chan6m):nth-child(2)')
    Adresselement = Listing-Karte.Wählen Sie eine('div[Klasse*="Preiskategorie"] div > p > span:letztes-Kind')

    Rückkehr {
        "Restaurantname": name_element.text.strip() if Namenselement sonst Keine,
        "Bewertung": Bewertungselement.text.strip() if Bewertungselement sonst Keine,
        „Anzahl der Bewertungen“: review_count_element.text.strip() if Bewertungsanzahlelement sonst Keine,
        "Die Anschrift": Adresselement.text.strip() if Adresselement sonst Keine,
        "Preisklasse": Preisbereichselement.text.strip() if Preisbereichselement sonst Keine,
        "Beliebte Artikel": ','.join([element.text.strip() 
für Element in beliebte_Artikel_Elemente]) if beliebte_artikel_elemente sonst Keine
    }

def extract_restaurants_info(HTML-Inhalt):
    """Restaurantdetails aus dem HTML-Inhalt extrahieren."""
    Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
    Auflistungskarten = Suppe.Auswahl('div[data-testid="serp-ia-card"]:not(.ABP)')

    Rückkehr [extract_restaurant_info(Karte) 
für Karte in Auflistungskarten]

if __name__ == "__hauptsächlich__":
    yelp_url = „https://www.yelp.com/search?find_desc=Italian+Restaurants&find_loc=San+Francisco%2C+CA“
    html_content = Yelp-Seite abrufen(Yelp-URL)

    if HTML-Inhalt:
        Restaurants_Daten = Extrahieren_von_Restaurantinformationen(HTML-Inhalt)
        drucken(json.dumps(restaurants_data, Einzug=2))

Dieses Python-Skript verwendet die CrawlingAPI aus der Crawlbase-Bibliothek, um Webinhalte abzurufen. Die Hauptfunktionen sind:

1. fetch_yelp_page(url): Ruft mithilfe von Crawlbase HTML-Inhalte von einer angegebenen URL ab.
2. extract_restaurant_info(listing_card): Analysiert die Details eines einzelnen Restaurants anhand seiner HTML-Karte.
3. extract_restaurants_info(html_content): Sammelt alle Restaurantdetails aus dem gesamten HTML der Yelp-Seite.

Bei direkter Ausführung ruft es Daten zu italienischen Restaurants in San Francisco von Yelp ab und gibt sie als formatiertes JSON aus.

Ausgabebeispiel:

[
  {
    "Restaurantname": "Bella Trattoria",
    "Bewertung": "4.3",
    „Anzahl der Bewertungen“: „(1.9k Bewertungen)“,
    "Die Anschrift": "Inneres Richmond",
    "Preisklasse": „$$“,
    "Beliebte Artikel": "Italienisch, Bars, Pasta-Läden"
  },
  {
    "Restaurantname": "Bottega",
    "Bewertung": "4.3",
    „Anzahl der Bewertungen“: "(974 Bewertungen)",
    "Die Anschrift": "Mission",
    "Preisklasse": „$$“,
    "Beliebte Artikel": "Italienisch, Pasta-Läden, Pizza"
  },
  {
    "Restaurantname": "Unter dem Meer",
    "Bewertung": "4.3",
    „Anzahl der Bewertungen“: „(5.2k Bewertungen)“,
    "Die Anschrift": „North Beach/Telegraph Hill“,
    "Preisklasse": „$$“,
    "Beliebte Artikel": "Meeresfrüchte, Italienisch, Bars"
  },
  {
    "Restaurantname": "Bagatella",
    "Bewertung": "4.8",
    „Anzahl der Bewertungen“: "(50 Bewertungen)",
    "Die Anschrift": "Marina/Kuhhöhle",
    "Preisklasse": null,
    "Beliebte Artikel": „Neuamerikanisch, Italienisch, Mediterran“
  },
  {
    "Restaurantname": "Ofen",
    "Bewertung": "4.5",
    „Anzahl der Bewertungen“: "(58 Bewertungen)",
    "Die Anschrift": "Seeufer",
    "Preisklasse": null,
    "Beliebte Artikel": "Italienisch, Bars"
  },
  {
    "Restaurantname": "Casaro Osteria",
    "Bewertung": "4.4",
    „Anzahl der Bewertungen“: "(168 Bewertungen)",
    "Die Anschrift": "Marina/Kuhhöhle",
    "Preisklasse": „$$“,
    "Beliebte Artikel": "Pizza, Cocktailbars"
  },
  {
    "Restaurantname": "Sieben Hügel",
    "Bewertung": "4.5",
    „Anzahl der Bewertungen“: „(1.3k Bewertungen)“,
    "Die Anschrift": "Russischer Hügel",
    "Preisklasse": "$$$",
    "Beliebte Artikel": "Italienisch, Weinbars"
  },
  {
    "Restaurantname": "Fiorella - Sonnenuntergang",
    "Bewertung": "4.1",
    „Anzahl der Bewertungen“: "(288 Bewertungen)",
    "Die Anschrift": "Innerer Sonnenuntergang",
    "Preisklasse": "$$$",
    "Beliebte Artikel": "Italienisch, Pizza, Cocktailbars"
  },
  {
    "Restaurantname": "Pasta Supply Co.",
    "Bewertung": "4.4",
    „Anzahl der Bewertungen“: "(127 Bewertungen)",
    "Die Anschrift": "Inneres Richmond",
    "Preisklasse": „$$“,
    "Beliebte Artikel": "Pasta-Läden"
  },
  {
    "Restaurantname": „Trattoria da Vittorio – San Francisco“,
    "Bewertung": "4.3",
    „Anzahl der Bewertungen“: "(963 Bewertungen)",
    "Die Anschrift": "Westportal",
    "Preisklasse": „$$“,
    "Beliebte Artikel": "Italienisch, Pizza"
  }
]

Einbinden der Paginierung für Yelp

Die Paginierung ist entscheidend, wenn Plattformen wie Yelp, die Ergebnisse auf mehreren Seiten anzeigen, durchsucht werden. Jede Seite enthält normalerweise eine Teilmenge der Ergebnisse, und ohne die Paginierung würden Sie nur die Daten der ersten Seite durchsehen. Um umfassende Daten abzurufen, ist es wichtig, jede Seite mit Ergebnissen zu durchlaufen.

Um dies mit Yelp zu erreichen, verwenden wir den URL-Parameter &start= das den Startpunkt für die auf jeder Seite angezeigten Ergebnisse angibt.

Aktualisieren wir den vorhandenen Code, um die Paginierung zu integrieren:

für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren JSON

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

def Yelp-Seite abrufen(URL):
    """Den Inhalt der Yelp-Seite abrufen und dekodieren."""
    # ... [Rest der Funktion bleibt unverändert]

def extract_restaurant_info(Listing-Karte):
    """Extrahieren Sie Details aus einer einzelnen Restaurant-Eintragskarte."""
    # ... [Rest der Funktion bleibt unverändert]

def extract_restaurants_info(HTML-Inhalt):
    """Restaurantdetails aus dem HTML-Inhalt extrahieren."""
    # ... [Rest der Funktion bleibt unverändert]

if __name__ == "__hauptsächlich__":
    Basis-URL = „https://www.yelp.com/search?find_desc=Italian+Restaurants&find_loc=San+Francisco%2C+CA“
    alle_restaurants_daten = []
    # Passen Sie den Bereich entsprechend der Anzahl der Ergebnisse an, die Sie scrapen möchten
    
für Anfang in Angebot(0, 51, 10):
        yelp_url = Basis-URL + f"&start={Start}"
        html_content = Yelp-Seite abrufen(Yelp-URL)
        if HTML-Inhalt:
            Restaurants_Daten = Extrahieren_von_Restaurantinformationen(HTML-Inhalt)
            all_restaurants_data.extend(restaurants_data)

    drucken(json.dumps(alle_restaurants_daten, Einzug=2))

Im aktualisierten Code durchlaufen wir den Bereich von start Werte (0, 10, 20, …, 50), um Daten von jeder Seite der Yelp-Suchergebnisse abzurufen. Anschließend erweitern wir die all_restaurants_data Liste mit den Daten von jeder Seite. Denken Sie daran, den Bereich anzupassen, wenn Sie mehr oder weniger Ergebnisse scrapen möchten.

Speichern und Analysieren von Yelp-Daten

Sobald Sie erfolgreich Daten von Yelp gescrapt haben, sind die nächsten wichtigen Schritte das Speichern dieser Daten für die zukünftige Verwendung und das Extrahieren von Erkenntnissen daraus. Die von Ihnen gesammelten Daten können für verschiedene Anwendungen von unschätzbarem Wert sein, von Geschäftsstrategien bis hin zur akademischen Forschung. In diesem Abschnitt erfahren Sie, wie Sie Ihre gescrapten Yelp-Daten effizient speichern und welche potenziellen Anwendungen diese Daten bieten.

Speichern von Daten in einer CSV-Datei

CSV ist ein weithin anerkanntes Dateiformat für tabellarische Daten. Es bietet eine einfache und effiziente Möglichkeit, Ihre Yelp-Daten zu archivieren und freizugeben. Pythons pandas Die Bibliothek bietet eine benutzerfreundliche Schnittstelle zur Handhabung von Datenoperationen, einschließlich der Möglichkeit, Daten in eine CSV-Datei zu schreiben.

Aktualisieren wir das vorherige Skript, um diese Änderung zu integrieren:

für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren Pandas as pd

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

def Yelp-Seite abrufen(URL):
    """Den Inhalt der Yelp-Seite abrufen und dekodieren."""
    # ... [Rest der Funktion bleibt unverändert]

def extract_restaurant_info(Listing-Karte):
    """Extrahieren Sie Details aus einer einzelnen Restaurant-Eintragskarte."""
    # ... [Rest der Funktion bleibt unverändert]

def extract_restaurants_info(HTML-Inhalt):
    """Restaurantdetails aus dem HTML-Inhalt extrahieren."""
    # ... [Rest der Funktion bleibt unverändert]

def als CSV speichern(Datenliste, Dateiname):
    """Daten mit Pandas in einer CSV-Datei speichern."""
    df = pd.DataFrame(Datenliste)
    df.to_csv(Dateiname, Index=falsch)

if __name__ == "__hauptsächlich__":
    Basis-URL = „https://www.yelp.com/search?find_desc=Italian+Restaurants&find_loc=San+Francisco%2C+CA“
    alle_restaurants_daten = []
    # Passen Sie den Bereich entsprechend der Anzahl der Ergebnisse an, die Sie scrapen möchten
    
für Anfang in Angebot(0, 51, 10):
        yelp_url = Basis-URL + f"&start={Start}"
        html_content = Yelp-Seite abrufen(Yelp-URL)
        if HTML-Inhalt:
            Restaurants_Daten = Extrahieren_von_Restaurantinformationen(HTML-Inhalt)
            all_restaurants_data.extend(restaurants_data)

    in CSV speichern (alle Restaurantdaten, „yelp_restaurants.csv“)

Die save_to_csv Die Funktion verwendet Pandas, um eine gegebene Datenliste in einen DataFrame zu konvertieren und speichert sie dann als CSV-Datei mit dem angegebenen Dateinamen.

yelp_restaurants.csv Vorschau:

Speichern von Daten in einer SQLite-Datenbank

SQLite ist eine leichte, festplattenbasierte Datenbank, die keinen separaten Serverprozess benötigt. Sie ist ideal für kleinere Anwendungen oder wenn Sie eine eigenständige Datenbank benötigen. Pythons sqlite3 Die Bibliothek ermöglicht Ihnen die nahtlose Interaktion mit SQLite-Datenbanken.

Aktualisieren wir das vorherige Skript, um diese Änderung zu integrieren:

importieren sqlite3
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe

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

def Yelp-Seite abrufen(URL):
    """Den Inhalt der Yelp-Seite abrufen und dekodieren."""
    # ... [Rest der Funktion bleibt unverändert]

def extract_restaurant_info(Listing-Karte):
    """Extrahieren Sie Details aus einer einzelnen Restaurant-Eintragskarte."""
    # ... [Rest der Funktion bleibt unverändert]

def extract_restaurants_info(HTML-Inhalt):
    """Restaurantdetails aus dem HTML-Inhalt extrahieren."""
    # ... [Rest der Funktion bleibt unverändert]

def in_Datenbank speichern(Datenliste, Datenbankname):
    """Daten in einer SQLite-Datenbank speichern."""
    conn = sqlite3.connect(Datenbankname)
    Cursor = conn.cursor()

    # Tabelle erstellen
    Cursor.ausführen('' '
        Tabelle erstellen, wenn nicht vorhanden Restaurants (
            ID INTEGER PRIMARY KEY AUTOINCREMENT,
            Name TEXT,
            Bewertung REAL,
            Anzahl der Bewertungen INTEGER,
            Adresse TEXT,
            Preisspanne TEXT,
            popular_items TEXT
        )
    '' ')

    # Daten einfügen
    
für Restaurant in Datenliste:
        Cursor.ausführen(„INSERT INTO Restaurants (Name, Bewertung, Anzahl der Rezensionen, Adresse, Preisspanne, beliebte Artikel) VALUES (?, ?, ?, ?, ?, ?)“,
                       (Restaurant["Restaurantname"], Restaurant["Bewertung"], Restaurant[„Anzahl der Bewertungen“], Restaurant["Die Anschrift"], Restaurant["Preisklasse"], Restaurant["Beliebte Artikel"]))

    conn.commit()
    conn.close()

if __name__ == "__hauptsächlich__":
    Basis-URL = „https://www.yelp.com/search?find_desc=Italian+Restaurants&find_loc=San+Francisco%2C+CA“
    alle_restaurants_daten = []
    # Passen Sie den Bereich entsprechend der Anzahl der Ergebnisse an, die Sie scrapen möchten
    
für Anfang in Angebot(0, 51, 10):
        yelp_url = Basis-URL + f"&start={Start}"
        html_content = Yelp-Seite abrufen(Yelp-URL)
        if HTML-Inhalt:
            Restaurants_Daten = Extrahieren_von_Restaurantinformationen(HTML-Inhalt)
            all_restaurants_data.extend(restaurants_data)

    in Datenbank speichern(alle Restaurantdaten, „yelp_restaurants.db“)

Die save_to_database Die Funktion speichert Daten aus einer Liste in einer SQLite-Datenbank. Sie stellt zunächst eine Verbindung zur Datenbank her und stellt sicher, dass eine Tabelle mit dem Namen „Restaurants“ mit bestimmten Spalten vorhanden ist. Anschließend fügt sie die Daten jedes Restaurants aus der Liste in diese Tabelle ein. Nachdem alle Daten eingefügt wurden, speichert sie die Änderungen und schließt die Datenbankverbindung.

restaurants Tabellenvorschau:

So nutzen Sie ausgelesene Yelp-Daten für geschäftliche oder Forschungszwecke

Yelp bietet mit seinem riesigen Archiv an Rezensionen, Bewertungen und anderen geschäftsbezogenen Informationen eine wahre Goldgrube an Erkenntnissen für Unternehmen und Forscher. Nachdem Sie diese Daten gesammelt haben, besteht der nächste Schritt darin, sie zu analysieren und zu visualisieren, um umsetzbare Erkenntnisse zu gewinnen.

Geschäftseinblicke:

1. Competitive Analysis: Durch die Analyse von Bewertungen und Rezensionen von Wettbewerbern können Unternehmen Verbesserungsbereiche in ihren eigenen Angeboten identifizieren.
2. Kundenpräferenzen: Verstehen Sie, was Kunden an ähnlichen Unternehmen mögen oder nicht, und passen Sie Ihre Strategien entsprechend an.
3. Trend Spek: Identifizieren Sie aufkommende Trends auf dem Markt, indem Sie Bewertungsmuster und beliebte Artikel analysieren.

Forschungsmöglichkeiten:

1. Konsumentenverhalten: Tauchen Sie tief in die Kundenbewertungen ein, um Kaufverhalten, Präferenzen und Schwachstellen zu verstehen.
2. Markt-Trends: Beobachten Sie Veränderungen der Verbraucherstimmung im Zeitverlauf, um sich entwickelnde Markttrends zu erkennen.
3. Geografische Analyse: Vergleichen Sie die Geschäftsleistung, Bewertungen und Rezensionen an verschiedenen Standorten.

Visualisierung der Daten:

Um die Daten leichter verdaulich und ansprechender zu machen, spielen Visualisierungen eine entscheidende Rolle. Betrachten wir ein einfaches Beispiel: ein Balkendiagramm, das zeigt, wie die durchschnittlichen Bewertungen in verschiedenen Preisklassen variieren.

importieren matplotlib.pyplot as plt
importieren Pandas as pd
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
für sklearn.Vorverarbeitung importieren LabelEncoder

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

def Yelp-Seite abrufen(URL):
    """Den Inhalt der Yelp-Seite abrufen und dekodieren."""
    # ... [Rest der Funktion bleibt unverändert]

def extract_restaurant_info(Listing-Karte):
    """Extrahieren Sie Details aus einer einzelnen Restaurant-Eintragskarte."""
    # ... [Rest der Funktion bleibt unverändert]

def extract_restaurants_info(HTML-Inhalt):
    """Restaurantdetails aus dem HTML-Inhalt extrahieren."""
    # ... [Rest der Funktion bleibt unverändert]

def plot_graph(die Datenerfassung):
    # Daten in Pandas DataFrame konvertieren
    df = pd.DataFrame(Daten)

    # LabelEncoder initialisieren
    label_encoder = LabelEncoder()

    # Spalte „Preisspanne“ kodieren
    df [„Preisspanne kodiert“] = label_encoder.fit_transform(df['Preisklasse'])

    # Spalte „Bewertung“ in Float umwandeln
    df ['Bewertung'] = pd.zu_numerisch(df['Bewertung'], Fehler='zwingen', niedergeschlagen ='schweben')

    # Zeilen löschen, bei denen „Bewertung“ NaN ist
    df = df.dropna(Teilmenge=['Bewertung'])

    # Berechnen Sie durchschnittliche Bewertungen für jede Preisspanne
    Durchschnittliche Bewertungen = df.groupby(„Preisspanne kodiert“)["Bewertung"].bedeuten()

    # Drucken Sie Originaletiketten und ihre codierten Werte
    original_labels = label_encoder.klassen_
    
für kodierter_Wert, Bezeichnung in aufzählen(Originalbeschriftungen):
        drucken(f"Preisspanne Wert: {kodierter_Wert} entspricht Label: {Etikett}")

    # Balkendiagramm erstellen
    plt.figure (figsize = (10, 6))
    avg_ratings.plot(Art='Bar', Farbe='himmelblau')
    plt.title („Durchschnittliche Bewertungen nach Preisklasse“)
    plt.xlabel ('Preisklasse')
    plt.ylabel („Durchschnittliche Bewertung“)
    plt.xticks(Rotation=45)
    plt.grid(Achse='y', Linienstil='--', alpha=0.7)
    plt.enges_layout()

    # Handlung anzeigen
    plt.show ()

if __name__ == "__hauptsächlich__":
    Basis-URL = „https://www.yelp.com/search?find_desc=Italian+Restaurants&find_loc=San+Francisco%2C+CA“
    alle_restaurants_daten = []
    # Passen Sie den Bereich entsprechend der Anzahl der Ergebnisse an, die Sie scrapen möchten
    
für Anfang in Angebot(0, 51, 10):
        yelp_url = Basis-URL + f"&start={Start}"
        html_content = Yelp-Seite abrufen(Yelp-URL)
        if HTML-Inhalt:
            Restaurants_Daten = Extrahieren_von_Restaurantinformationen(HTML-Inhalt)
            all_restaurants_data.extend(restaurants_data)

    Plotgraph (alle Restaurantdaten)

Ausgabediagramm:

Dieses Diagramm kann ein nützliches Instrument zum Verständnis der Kundenwahrnehmung auf Grundlage der Preisgestaltung sein und als Leitfaden für Preisstrategien oder Marketingbemühungen von Restaurants dienen.

Erstellen Sie mit Crawlbase einen Yelp Scraper

Dieser Leitfaden vermittelt Ihnen das grundlegende Know-how und die Werkzeuge, um mit Python und Crawlbase ganz einfach Yelp-Sucheinträge zu scrapen. Crawling API. Egal, ob Sie neu in diesem Bereich sind oder bereits über Erfahrung verfügen, die hier erläuterten Ideen bieten einen guten Ausgangspunkt für Ihre Bemühungen.

Wenn Sie Ihre Web Scraping-Reise fortsetzen, denken Sie daran, dass die Vielseitigkeit dieser Fähigkeiten über Yelp hinausgeht. Entdecken Sie unsere zusätzlichen Anleitungen für Plattformen wie Expedia, DeviantArt, Airbnb und Glassdoor, und erweitern Sie Ihr Scraping-Know-how.

Web Scraping stellt Herausforderungen dar, und unser Engagement für Ihren Erfolg geht über diesen Leitfaden hinaus. Wenn Sie auf Hindernisse stoßen oder weitere Anleitung benötigen, Crawlbase-Supportteam ist bereit, Ihnen zu helfen. Ihr Erfolg beim Web Scraping ist unsere Priorität und wir freuen uns darauf, Sie auf Ihrem Scraping-Weg zu unterstützen.

Häufig gestellte Fragen

F: Ist das Scraping von Yelp.com legal?

Web Scraping-Aktivitäten bewegen sich oft auf einem schmalen Grat zwischen Legalität und Ethik. Wenn es um Plattformen wie Yelp geht, ist es wichtig, zuerst die Servicebedingungen von Yelp zu lesen und robots.txt Datei. Diese Dokumente geben Aufschluss darüber, welche Aktivitäten die Plattform erlaubt und einschränkt. Auch wenn die Inhalte von Yelp öffentlich zugänglich sind, kann die Art und Weise und das Ausmaß, in dem Sie darauf zugreifen, als missbräuchlich oder böswillig angesehen werden. Darüber hinaus kann das Scraping persönlicher Daten aus Benutzerbewertungen oder -profilen gegen Datenschutzbestimmungen in verschiedenen Rechtsgebieten verstoßen. Achten Sie immer darauf, sowohl die Richtlinien der Plattform als auch die geltenden Gesetze zu verstehen und einzuhalten.

F: Wie oft sollte ich meine gesammelten Yelp-Daten aktualisieren?

Die Häufigkeit der Aktualisierung Ihrer Scraped-Daten hängt von der Art Ihres Projekts und der Dynamik der Daten auf Yelp ab. Wenn Ihr Ziel darin besteht, Echtzeittrends, Benutzerbewertungen oder aktuelle Preisinformationen zu erfassen, sind möglicherweise häufigere Aktualisierungen erforderlich. Zu häufiges Scraping kann jedoch die Server von Yelp belasten und möglicherweise dazu führen, dass Ihre IP-Adresse blockiert wird. Es ist ratsam, ein Gleichgewicht zu finden: Bestimmen Sie, wie wichtig zeitnahe Aktualisierungen für Ihr Projekt sind, und gehen Sie gleichzeitig respektvoll mit der Infrastruktur von Yelp um. Die Überwachung der Aktualisierungshäufigkeiten von Yelp oder das Einrichten von Benachrichtigungen für wesentliche Änderungen können auch Ihre Scraping-Intervalle bestimmen.

F: Kann ich die gesammelten Yelp-Daten für kommerzielle Zwecke verwenden?

Die Verwendung von Scraped-Daten von Plattformen wie Yelp für kommerzielle Zwecke ist mit komplizierten Herausforderungen verbunden. Die Nutzungsbedingungen von Yelp verbieten das Scraping ausdrücklich, und die unberechtigte Nutzung der Daten zu kommerziellen Zwecken kann rechtliche Konsequenzen nach sich ziehen. Es ist äußerst wichtig, sich an Rechtsexperten zu wenden, um die Nuancen der Datennutzungsrechte und des geistigen Eigentumsrechts zu verstehen. Wenn ein echter Bedarf besteht, Yelp-Daten kommerziell zu nutzen, sollten Sie sich an die Datenpartnerschaften oder Lizenzierungsabteilungen von Yelp wenden. Diese bieten möglicherweise Möglichkeiten für den Erhalt legitimer Zugriffs- oder Partnerschaftsmöglichkeiten. Priorität haben immer Transparenz, ethische Datennutzung und das Einholen ausdrücklicher Genehmigungen, um Risiken zu minimieren.

F: Wie kann ich die Genauigkeit meiner gesammelten Yelp-Daten sicherstellen?

Die Gewährleistung der Genauigkeit und Zuverlässigkeit der Scraped-Daten ist die Grundlage für jedes datengesteuerte Projekt. Wenn Sie Daten von Yelp oder ähnlichen Plattformen scrapen, implementieren Sie zunächst robuste Fehlerbehandlungsmechanismen in Ihre Scraping-Skripte. Diese Mechanismen können häufige Probleme wie Verbindungstimeouts, unvollständige Datenabrufe oder Nichtübereinstimmungen erkennen und beheben. Validieren Sie die extrahierten Daten regelmäßig anhand der Live-Quelle, um sicherzustellen, dass Ihre Scraping-Logik mit allen Änderungen auf der Yelp-Website konsistent bleibt. Erwägen Sie außerdem die Implementierung von Datenvalidierungsprüfungen nach dem Scraping, um Anomalien oder Inkonsistenzen zu erkennen. Regelmäßige manuelle Überprüfungen oder Querverweise mit vertrauenswürdigen Sekundärquellen können als weitere Validierungsebenen dienen und die Gesamtqualität und Vertrauenswürdigkeit Ihres Scraped-Yelp-Datensatzes verbessern.