Trulia, eine beliebte Immobilien-Website, bietet eine Fülle von Informationen, die genutzt werden können, um Erkenntnisse und Trends zu gewinnen. Trulia bietet eine große Menge an Immobiliendaten, darunter Immobilienangebote, Preise und Markttrends. Mit seiner benutzerfreundlichen Oberfläche und den umfassenden Daten ist Trulia sowohl für Immobilienkäufer als auch für Immobilienprofis eine Anlaufstelle.

Mit 46.5 Millionen Besuche im Februar 2024Trulia ist das Hauptziel für die Extraktion und Analyse wertvoller Daten, da Millionen von Benutzern jeden Monat aktiv nach Häusern, Wohnungen und Mietobjekten suchen. Trulia ist ein Immobilienriese mit Millionen von Immobiliendatensätzen und damit eine Goldgrube für Marktanalysen und -forschung.

Das Scraping von Trulia kann besonders für Immobilienprofis, Investoren oder Forscher nützlich sein, die Marktdynamiken analysieren, Investitionsmöglichkeiten identifizieren oder Immobilienpreise verfolgen möchten. Mit Web Scraping können Sie aktuelle Informationen effizient sammeln und sich einen Wettbewerbsvorteil verschaffen.

In dieser Schritt-für-Schritt-Anleitung führen wir Sie durch den gesamten Prozess zum Scrapen von Trulia mit der Sprache Python. Also, fangen wir an!

Inhaltsverzeichnis

  1. Projektumfang verstehen
  2. Voraussetzungen:
  3. Projektaufbau
  • Abhängigkeiten installieren
  • Auswahl einer IDE
  1. Extrahieren von Trulia SERP HTML
  • Extrahieren von HTML mit einem allgemeinen Ansatz
  • Herausforderungen beim Scraping von Trulia mit einem gängigen Ansatz
  • Extrahieren von HTML mit Crawlbase Crawling API
  1. Trulia SERP-Eintrag scrapen
  2. Trulia-Preis abkratzen
  3. Trulia-Adresse scrapen
  4. Größe der Trulia-Immobilie ermitteln
  5. Anzahl der Schlafzimmer in der Trulia-Immobilie abfragen
  6. Anzahl der Badezimmer in der Trulia-Immobilie abfragen
  7. Scrape Trulia Immobilienmakler
  8. Trulia-Bilder scrapen
  9. Link zur Immobilienseite von Trulia scrapen
  10. Code vervollständigen
  11. Seitennummerierung handhaben und Daten speichern
  • Umgang mit Paginierung
  • Speichern von Scraped-Daten in einer Excel-Datei
  • Integrieren von Paginierung und Speichervorgängen in das Skript
  1. Abschließende Überlegungen
  2. Häufig gestellte Fragen (FAQs)
  • Ist das Scrapen von Trulia legal?
  • Warum Trulia scrapen?
  • Was können Sie von Trulia scrapen?
  • Was sind die besten Möglichkeiten zum Scrapen von Trulia?

1. Den Projektumfang verstehen

In diesem Leitfaden ist es unser Ziel, ein benutzerfreundliches Tutorial zum Scraping von Trulia mit Python und der Crawlbase zu erstellen. Crawling API. Der Projektumfang umfasst die Nutzung wichtiger Tools wie Pythons BeautifulSoup-Bibliothek für HTML-Parsing und die Crawlbase Crawling API für einen effizienten Datenextraktionsprozess.

Wir konzentrieren uns auf das Scraping verschiedener Elemente aus Trulia-Einträgen, darunter Namen, Adressen, Bewertungen, Rezensionen und Bilder von UnterkünftenDas Ziel besteht darin, einen schrittweisen Ansatz bereitzustellen, der es Benutzern mit unterschiedlichem technischen Kenntnisstand zugänglich macht.

Schlüsselkomponenten des Projekts:

  1. HTML-Crawling: Wir werden Python zusammen mit der Crawlbase verwenden Crawling API um den vollständigen HTML-Inhalt der Trulia-Einträge abzurufen. Dies gewährleistet eine effektive Datenextraktion unter Einhaltung der Nutzungsrichtlinien von Trulia. Die Ziel-URL für dieses Projekt wird für eine praktische Erfahrung bereitgestellt.

Wir werden die Trulia-Immobilienliste für den Standort „Los Angeles, CA“ von dieser URL extrahieren.

SERP von Trulia
  1. Datenextraktion aus Trulia: Unser Hauptaugenmerk liegt auf der Verwendung von BeautifulSoup in Python, um bestimmte Datenelemente aus Trulia-Einträgen zu extrahieren. Dazu gehört das Scraping von Immobiliennamen, Adressen, Bewertungen, Rezensionen und Bildern.
  2. Umgang mit Paginierung: Um mehrere Seiten mit Trulia-Einträgen abzudecken, besprechen wir Techniken zur Seitennummerierung, um sicherzustellen, dass alle relevanten Daten erfasst werden.
  3. Daten speichern: Wir untersuchen Möglichkeiten zum Speichern oder Sichern der Scraped-Daten und bieten Optionen wie das Speichern in einer CSV-Datei zur weiteren Analyse.

Indem wir den Projektumfang skizzieren, möchten wir Sie durch ein umfassendes Tutorial zum Trulia-Scraping führen und Ihnen den Prozess verständlich und durchführbar machen. Kommen wir nun zu den Voraussetzungen des Projekts.

2. Voraussetzungen

Bevor wir in die Welt des Web Scraping von Trulia mit Python eintauchen, legen wir die wesentlichen Voraussetzungen für einen reibungslosen Ablauf fest:

  1. Grundkenntnisse in Python:

Ein grundlegendes Verständnis der Programmiersprache Python ist entscheidend. Wenn Sie neu in Python sind, sollten Sie sich die Einführung ansehen. Tutorials oder Kurse zum Erlernen der Grundlagen.

  1. Crawlbase-Konto mit API-Anmeldeinformationen:

Besorgen Sie sich ein aktives Konto bei Crawlbase sowie API-Anmeldeinformationen, um programmgesteuert auf Trulia-Seiten zuzugreifen. Registrieren für die Crawlbase Crawling API um Ihre ersten 1,000 Anfragen zu erhalten und Ihre API-Anmeldeinformationen vor dem Kontodokumentation.

  1. Auswählen eines Tokens:

Crawlbase bietet zwei Arten von Tokens – einen für statische Websites und einen für dynamische oder JavaScript-basierte Websites. Trulia verwendet JS-Rendering, um Daten auf die Website zu laden. Daher verwenden wir JS-Tokens.

  1. Auf Ihrem Computer installiertes Python:

Sie können Python von der offiziellen Python-Website basierend auf Ihrem Betriebssystem. Bestätigen Sie außerdem das Vorhandensein von pip (Python-Paketmanager), der normalerweise mit Python-Installationen mitgeliefert wird.

1
2
3
4
5
# Verwenden Sie diesen Befehl, um die Python-Installation zu überprüfen
Python --Version

# Verwenden Sie diesen Befehl, um die Pip-Installation zu überprüfen
pip --version

3. Projekt-Setup

Bevor wir uns in das Scraping von trulia.com stürzen, richten wir unser Projekt ein, um sicherzustellen, dass wir alles haben, was wir brauchen.

Abhängigkeiten installieren

Jetzt richten wir unsere Tools ein, indem wir die erforderlichen Bibliotheken installieren. Diese Bibliotheken sind wie die Superhelden, die uns dabei helfen, Trulia mühelos zu scrapen. Befolgen Sie diese einfachen Schritte:

  1. Öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung:

Öffnen Sie je nach Betriebssystem das Terminal oder die Eingabeaufforderung.

  1. Installieren requests:

Mithilfe der Requests-Bibliothek können wir ganz einfach HTTP-Anfragen stellen. Geben Sie den folgenden Befehl ein und drücken Sie die Eingabetaste:

1
Pip Installationsanforderungen
  1. Installieren beautifulsoup4:

BeautifulSoup unterstützt die HTML-Analyse und ermöglicht uns eine nahtlose Navigation und Datenextraktion. Verwenden Sie den folgenden Befehl, um es zu installieren:

1
pip install beautifulsoup4
  1. Installieren pandas:

Pandas ist unser Kraftpaket zur Datenmanipulation und ermöglicht die effiziente Handhabung von Scraped-Daten. Führen Sie den folgenden Befehl aus, um es zu installieren:

1
Pandas installieren
  1. Crawlbase installieren:

Die Crawlbase-Bibliothek integriert sich in die Crawlbase Crawling API, wodurch unser Web Scraping-Prozess optimiert wird. Installieren Sie die Crawlbase-Bibliothek mit diesem Befehl:

1
pip installieren crawlbase

Auswahl einer IDE

Nachdem Python und die wesentlichen Bibliotheken nun bereit sind, wählen wir eine integrierte Entwicklungsumgebung (IDE) aus, um das Programmieren einfach und angenehm zu gestalten. Es stehen mehrere IDEs zur Verfügung. Hier sind einige benutzerfreundliche Optionen für Python:

  • Visual Studio Code: Es ist leicht und einfach, perfekt für Programmieranfänger.
  • PyCharm: Eine mit zahlreichen Funktionen ausgestattete Wahl, die in professionellen Umgebungen weit verbreitet ist.
  • Jupyter Notizbücher: Ideal für interaktive und explorative Codierungsabenteuer.

Im nächsten Abschnitt beginnen wir mit der Datenextraktion aus einer einzelnen Immobilie auf trulia.com. Das Scraping-Abenteuer kann beginnen!

4. Extrahieren von Trulia SERP HTML

Wenn es um das Scraping von Trulia geht, besteht unser erster Schritt darin, den rohen HTML-Inhalt der Suchmaschinen-Ergebnisseite (SERP) abzurufen. Dies legt die Grundlage für die Extraktion wertvoller Informationen. Lassen Sie uns zwei Methoden untersuchen: den üblichen Ansatz und den intelligenten Ansatz mithilfe der Crawlbase Crawling API.

Extrahieren von HTML mit einem allgemeinen Ansatz

Wenn es um das Extrahieren von HTML geht, besteht der übliche Ansatz darin, Python-Bibliotheken zu verwenden wie requests und BeautifulSoup. Diese Bibliotheken ermöglichen es uns, Anfragen an die Website von Trulia zu senden und dann das empfangene HTML nach Daten zu analysieren.

1
2
3
4
5
6
7
8
9
10
importieren Zugriffe

# Geben Sie die Trulia SERP-URL an
trulia_serp_url = „https://www.trulia.com/CA/Los_Angeles/“

# Machen Sie eine GET-Anfrage, um das HTML abzurufen
Antwort = Anfragen.get(trulia_serp_url)

# Drucken Sie den HTML-Inhalt
drucken(Antwort.text)

Führen Sie das Skript aus:

Öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung und navigieren Sie zu dem Verzeichnis, in dem Sie trulia_scraper.py gespeichert haben. Führen Sie das Skript mit dem folgenden Befehl aus:

1
python trulia_scraper.py

Wenn Sie die Eingabetaste drücken, wird Ihr Skript aktiv, sendet eine Anfrage an die Trulia-Website, ruft den HTML-Inhalt ab und zeigt ihn auf Ihrem Terminal an.

Ausgabe-HTML-Schnappschuss

Herausforderungen beim Scraping von Trulia mit einem gängigen Ansatz

Wenn wir uns auf dem Weg befinden, Trulia zu scrapen, stoßen wir auf bestimmte Herausforderungen, wenn wir uns auf gängige oder traditionelle Ansätze verlassen. Lassen Sie uns diese Hürden beleuchten:

  1. Anti-Scraping-Maßnahmen

Trulia implementiert Sicherheitsvorkehrungen, um seine Website vor automatisiertem Scraping zu schützen. Diese Maßnahmen umfassen häufig CAPTCHAs und Ratenbegrenzungen, was es für herkömmliche Scraping-Methoden schwierig macht, Daten reibungslos zu erfassen.

Verwandte lesen: So umgehen Sie CAPTCHAS

  1. Dynamischer Inhalt

Die Website von Trulia nutzt JavaScript in großem Umfang, um dynamische Inhalte zu laden. Mit herkömmlichem Scraping können diese dynamischen Daten möglicherweise nur schwer effektiv erfasst werden, was zu einem unvollständigen oder ungenauen Informationsabruf führt.

Diese Herausforderungen unterstreichen die Notwendigkeit eines ausgefeilteren Ansatzes, den wir mithilfe der erweiterten Möglichkeiten des Crawlbase Crawling API in den folgenden Abschnitten.

Extrahieren von HTML mit Crawlbase Crawling API

Die Crawlbase Crawling API bietet eine robustere Lösung, die gängige Scraping-Herausforderungen überwindet. Es ermöglicht eine effiziente HTML-Extraktion, die Verarbeitung dynamischer Inhalte und stellt die Einhaltung der Nutzungsrichtlinien von Trulia sicher. Es Parameter ermöglichen uns die mühelose Erledigung verschiedener Schabeaufgaben.

Wir integrieren die ajax_wait und page_wait Parameter, um sicherzustellen, dass wir HTML erhalten, nachdem die Seite vollständig geladen wurde. Hier ist ein Beispiel für eine Python-Funktion unter Verwendung der Crawlbase-Bibliothek:

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

# Ersetzen Sie den Platzhalter „CRAWLBASE_JS_TOKEN“ durch Ihr JS-Token
crawling_api = CrawlingAPI({ 'Zeichen': 'CRAWLBASE_JS_TOKEN' })

Optionen = {
    'ajax_wait': "wahr",
    'Seite_warten': 8000
}

def Crawlbase-Anfrage erstellen(URL):
  globale  crawling_api, Optionen

  Antwort = crawling_api.get(URL, Optionen)

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

5. Trulia SERP-Eintrag scrapen

Bevor wir uns mit bestimmten Elementen befassen, erstellen wir eine Funktion, um alle Immobilienangebote aus der SERP abzurufen. Dies dient als Grundlage für die Extraktion einzelner Details.

Trulia-Sucheinträge scrapen

Jeder Eintrag ist im Inneren li Element und alle li Elemente sind im Inneren ul Element mit data-testid as search-result-list-container.

1
2
3
4
5
6
7
8
9
10
11
12
# Importieren Sie die erforderlichen Bibliotheken
für bs4 importieren BeautifulSuppe

# Funktion zum Scrapen der Trulia-Liste
def scrape_trulia_listings(HTML-Inhalt):
    versuchen:
        Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
        Auflistung_Container = Suppe.Auswahl('ul[data-testid="search-result-list-container"] > li')
        Rückkehr Auflistung_Container
    ausgeschlossen Exception as e:
        drucken(f"Beim Scrapen des Trulia-Eintrags ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

6. Trulia-Preise abkratzen

Erstellen wir eine Funktion, um die Immobilienpreise aus den Suchergebnissen zu extrahieren.

Trulia-Preis scrapen

Wenn Sie einen Preis prüfen, werden Sie sehen, dass er eingeschlossen ist in div die Klasse haben data-testid as property-price.

1
2
3
4
5
6
7
8
9
# Funktion zum Scrapen des Trulia-Preises
def scrape_trulia_preis(listing):
    versuchen:
        Preiselement = Auflistung.Wählen Sie eins aus('div[data-testid="property-price"]')
        Eigenschaftspreis = Preiselement.text.strip() if Preiselement sonst Keine
        Rückkehr Immobilienpreis
    ausgeschlossen Exception as e:
        drucken(f"Beim Scrapen des Trulia-Preises ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

7. Trulia-Adresse scrapen

Lassen Sie uns nun die Adressen der Immobilien abrufen.

Trulia-Adresse scrapen

Die Adresse ist beigefügt in div die Klasse haben data-testid as property-address.

1
2
3
4
5
6
7
8
9
# Funktion zum Scrapen der Trulia-Adresse
def scrape_trulia_adresse(listing):
    versuchen:
        Adresselement = Auflistung.Wählen Sie eins aus('div[data-testid="property-address"]')
        Eigenschaftsadresse = Adresselement.text.strip() if Adresselement sonst Keine
        Rückkehr Eigenschaftsadresse
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Trulia-Adresse ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

8. Größe der Immobilie bei Trulia ermitteln

Als Nächstes folgt das Extrahieren der Eigenschaftsgröße.

Größe der Immobilie bei Trulia ermitteln

Die Grundstücksgröße ist eingeschlossen in div die Klasse haben data-testid as property-floorSpace.

1
2
3
4
5
6
7
8
9
# Funktion zum Scrapen der Trulia-Eigenschaftsgröße
def Scrape_Trulia_Eigenschaftsgröße(listing):
    versuchen:
        Größenelement = Auflistung.Wählen Sie eins aus('div[data-testid="property-floorSpace"]')
        Eigenschaftsgröße = Größenelement.text.strip() if Größenelement sonst Keine
        Rückkehr Eigenschaftsgröße
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Trulia-Eigenschaftsgröße ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

9. Anzahl der Schlafzimmer auf Trulia-Immobilien durchsuchen

Lassen Sie uns nun eine Funktion erstellen, um die Anzahl der Schlafzimmer für die Immobilie zu ermitteln.

Die Anzahl der Schlafzimmer ist angegeben in div die Klasse haben data-testid as property-beds.

1
2
3
4
5
6
7
8
9
# Funktion zum Scrapen der Anzahl der Schlafzimmer einer Trulia-Immobilie
def Scrape_Trulia_Property_Schlafzimmeranzahl(listing):
    versuchen:
        Anzahl_Schlafzimmer = Auflistung.Wählen Sie_eins('div[data-testid="property-beds"]')
        property_bedrooms_count = Schlafzimmeranzahl_element.text.strip() if Anzahl der Schlafzimmer sonst Keine
        Rückkehr Anzahl der Schlafzimmer
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Schlafzimmeranzahl der Trulia-Immobilie ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

10. Trulia Property Badezimmer zählen

Lassen Sie uns nun eine Funktion erstellen, um die Anzahl der Bäder für die Immobilie zu ermitteln.

Die Anzahl der Bäder ist eingeschlossen in div die Klasse haben data-testid as property-baths.

1
2
3
4
5
6
7
8
9
# Funktion zum Scrapen der Badezimmeranzahl von Trulia-Immobilien
def Scrape_Trulia_Property_Bäder_Anzahl(listing):
    versuchen:
        Anzahl der Bäder = Auflistung.Wählen Sie eins aus('div[data-testid="property-baths"]')
        Eigenschaft_Anzahl Bäder = Anzahl Bäder_Element.Text.Strip() if Anzahl der Bäder sonst Keine
        Rückkehr Anzahl der Badezimmer
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Trulia-Badezimmeranzahl ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

11. Scrape Trulia Immobilienmakler

Lassen Sie uns jetzt Informationen zum Immobilienmakler einholen.

Scrape Trulia Immobilienmakler

Informationen zum Immobilienmakler finden Sie in einer div mit dem Attribut data-testid mit Wert property-card-listing-summary.

1
2
3
4
5
6
7
8
9
# Funktion zum Scrapen des Trulia-Immobilienmaklers
def scrape_trulia_property_agent(listing):
    versuchen:
        agent_info_element = Auflistung.Wählen Sie eine('div[data-testid="Zusammenfassung der Immobilienkarte"]')
        agent_info = agent_info_element.text.strip() if agent_info_element sonst Keine
        Rückkehr agent_info
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Immobilienmaklerinformationen von Trulia ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

12. Trulia-Bilder auslesen

Das Aufnehmen von Immobilienbildern ist von entscheidender Bedeutung. Hier ist eine Funktion zum Abrufen dieser Bilder.

Trulia-Bilder scrapen

Alle Bilder befinden sich in einem div mit der Klasse beginnend mit SwipeableContainer__Container. Sobald wir das Element haben, können wir alle img Element src Attribut, um Bildlinks zu erhalten.

13. Link zur Immobilienseite von Trulia scrapen

Holen wir uns jetzt den Link zur Detailseite der Immobilie.

Link zur Immobilienseite von Trulia scrapen

Der Link zur Immobilienseite befindet sich in einer a Element mit dem Attribut data-testid mit Wert property-card-link.

1
2
3
4
5
6
7
8
9
# Funktion zum Scrapen des Links zur Trulia-Immobilienseite
def Scrape_Trulia_Eigenschaftsseitenlink(listing):
    versuchen:
        property_link_element = Auflistung.Wählen Sie eine('a[data-testid="Eigenschaftskarten-Link"]')
        property_link = „https://www.trulia.com“ + Eigenschaftslinkelement['href'] if Eigenschaftslinkelement sonst Keine
        Rückkehr Eigenschaftslink
    ausgeschlossen Exception as e:
        drucken(f"Beim Scrapen des Trulia-Immobilienlinks ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

14. Code vervollständigen

Lassen Sie uns nun diese Funktionen kombinieren, um ein umfassendes Skript zum Scraping der Trulia-Suchergebnisse zu erstellen.

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
# Importieren Sie die erforderlichen Bibliotheken
für bs4 importieren BeautifulSuppe
für Crawlbase importieren CrawlingAPI
importieren JSON

# Ersetzen Sie den Platzhalter „CRAWLBASE_JS_TOKEN“ durch Ihr JS-Token
crawling_api = CrawlingAPI({ 'Zeichen': 'CRAWLBASE_JS_TOKEN' })

Optionen = {
    'ajax_wait': "wahr",
    'Seite_warten': 8000
}

def Crawlbase-Anfrage erstellen(URL):
  globale  crawling_api, Optionen

  Antwort = crawling_api.get(URL, Optionen)

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

# Funktion zum Scrapen der Trulia-Liste
def scrape_trulia_listings(HTML-Inhalt):
    versuchen:
        Suppe = Schöne Suppe (HTML-Inhalt, 'html.parser')
        Auflistung_Container = Suppe.Auswahl('ul[data-testid="search-result-list-container"] > li')
        Rückkehr Auflistung_Container
    ausgeschlossen Exception as e:
        drucken(f"Beim Scrapen des Trulia-Eintrags ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

# Funktion zum Scrapen des Trulia-Preises
def scrape_trulia_preis(listing):
    versuchen:
        Preiselement = Auflistung.Wählen Sie eins aus('div[data-testid="property-price"]')
        Eigenschaftspreis = Preiselement.text.strip() if Preiselement sonst Keine
        Rückkehr Immobilienpreis
    ausgeschlossen Exception as e:
        drucken(f"Beim Scrapen des Trulia-Preises ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

# Funktion zum Scrapen der Trulia-Adresse
def scrape_trulia_adresse(listing):
    versuchen:
        Adresselement = Auflistung.Wählen Sie eins aus('div[data-testid="property-address"]')
        Eigenschaftsadresse = Adresselement.text.strip() if Adresselement sonst Keine
        Rückkehr Eigenschaftsadresse
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Trulia-Adresse ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

# Funktion zum Scrapen der Trulia-Eigenschaftsgröße
def Scrape_Trulia_Eigenschaftsgröße(listing):
    versuchen:
        Größenelement = Auflistung.Wählen Sie eins aus('div[data-testid="property-floorSpace"]')
        Eigenschaftsgröße = Größenelement.text.strip() if Größenelement sonst Keine
        Rückkehr Eigenschaftsgröße
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Trulia-Eigenschaftsgröße ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

# Funktion zum Scrapen der Anzahl der Schlafzimmer einer Trulia-Immobilie
def Scrape_Trulia_Property_Schlafzimmeranzahl(listing):
    versuchen:
        Anzahl_Schlafzimmer = Auflistung.Wählen Sie_eins('div[data-testid="property-beds"]')
        property_bedrooms_count = Schlafzimmeranzahl_element.text.strip() if Anzahl der Schlafzimmer sonst Keine
        Rückkehr Anzahl der Schlafzimmer
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Schlafzimmeranzahl der Trulia-Immobilie ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

# Funktion zum Scrapen der Badezimmeranzahl von Trulia-Immobilien
def Scrape_Trulia_Property_Bäder_Anzahl(listing):
    versuchen:
        Anzahl der Bäder = Auflistung.Wählen Sie eins aus('div[data-testid="property-baths"]')
        Eigenschaft_Anzahl Bäder = Anzahl Bäder_Element.Text.Strip() if Anzahl der Bäder sonst Keine
        Rückkehr Anzahl der Badezimmer
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Trulia-Badezimmeranzahl ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

# Funktion zum Scrapen des Trulia-Immobilienmaklers
def scrape_trulia_property_agent(listing):
    versuchen:
        agent_info_element = Auflistung.Wählen Sie eine('div[data-testid="Zusammenfassung der Immobilienkarte"]')
        agent_info = agent_info_element.text.strip() if agent_info_element sonst Keine
        Rückkehr agent_info
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Immobilienmaklerinformationen von Trulia ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

# Funktion zum Scrapen von Trulia-Bildern
def scrape_trulia_images(listing):
    versuchen:
        Bildercontainer = Auflistung.Wählen Sie eine('div[Klasse^="SwipeableContainer__Container"]')
        Bild-URLs = [Bild['Quelle'] 
für img in Bildercontainer.find_all('img')] if Bildercontainer sonst Keine
        Rückkehr Bild-URLs
    ausgeschlossen Exception as e:
        drucken(f"Beim Scraping der Trulia-Bilder ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

# Funktion zum Scrapen des Links zur Trulia-Immobilienseite
def Scrape_Trulia_Eigenschaftsseitenlink(listing):
    versuchen:
        property_link_element = Auflistung.Wählen Sie eine('a[data-testid="Eigenschaftskarten-Link"]')
        property_link = „https://www.trulia.com“ + Eigenschaftslinkelement['href'] if Eigenschaftslinkelement sonst Keine
        Rückkehr Eigenschaftslink
    ausgeschlossen Exception as e:
        drucken(f"Beim Scrapen des Trulia-Immobilienlinks ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine


# Hauptfunktion zur Orchestrierung des Scraping-Prozesses
def Haupt-†
    # Geben Sie die Trulia SERP-URL an
    trulia_serp_url = „https://www.trulia.com/CA/Los_Angeles/“

    # Initialisieren Sie eine leere Liste, um die Scraped-Ergebnisse zu speichern
    scraped_results = []

    # HTML-Inhalt abrufen
    html_Inhalt = make_crawlbase_request(trulia_serp_url)

    # Trulia-Eintrag scrapen
    trulia_listings = scrape_trulia_listings(html_Inhalt)

    # Überprüfen Sie, ob trulia_listings leer ist
    if nicht trulia_listings:
        drucken(„Das Scraping der Trulia-Einträge ist fehlgeschlagen.“ 
für Seite {Seitennummer}.)
        Rückkehr

    
für trulia_listing in trulia_listings:

        # Einzelne Details scrapen
        Preis = Scrape_Trulia_Preis(Trulia_Listing)
        Adresse = Scrape_Trulia_Adresse(Trulia_Listing)
        Größe = Scrape_Trulia_Property_Größe(Trulia_Listing)
        Schlafzimmer = scrape_trulia_property_bedrooms_count(trulia_listing)
        Bäder = scrape_trulia_property_baths_count(trulia_listing)
        Agent = scrape_trulia_property_agent(Trulia-Auflistung)
        Bilder = scrape_trulia_images(trulia_listing)
        Link = Scrape_Trulia_Eigenschaftsseitenlink(Trulia_Eintrag)

        # Ergebnisse an die Liste anhängen
        result_dict = {
            'Immobilienpreis': Preis,
            'Adresse der Immobilie': Adresse,
            'Eigenschaftsgröße': Größe,
            „Schlafzimmer zählen“: Schlafzimmer,
            'Bäder zählen': Bäder,
            'Immobilienmakler': Vertreter,
            „Immobilienbilder“: Bilder,
            'Eigenschaftslink': Verknüpfung
        }
        scraped_results.append(Ergebnis_dict)

    # Drucken Sie die Scraped-Ergebnisse
    drucken(json.dumps(scraped_results, Einzug=2))

# Führen Sie die Hauptfunktion aus
if __name__ == "__hauptsächlich__":
    Main()

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
[
  {
    "Immobilienpreis": "$ 4,750,000",
    "Adresse der Immobilie": „9240 W National Blvd, Los Angeles, CA 90034“,
    "Grundstücksgröße": "6,045 m²",
    "Schlafzimmer zählen": "9bd",
    "Bäder zählen": "9ba",
    "Immobilienmakler": „Linda Moreh DRE # 01294670, Nelson Shelton Real Estate Era Powered“,
    "Immobilienbilder": [
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/08a4055f550f0fa020725a51462c640d-full.webp",
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/00dd9e16a4c3cd40828d42b466e6daa8-full.webp",
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/1ca58dfc05b73fe31d9eaadc3fb6ddce-full.webp"
    ],
    "Eigenschaftslink": „9240 W National Blvd, Los Angeles, CA 90034“
  },
  {
    "Immobilienpreis": "$ 3,695,000",
    "Adresse der Immobilie": „110 N Kings Rd, Los Angeles, CA 90048“,
    "Grundstücksgröße": "8,822 m²",
    "Schlafzimmer zählen": "8bd",
    "Bäder zählen": "8ba",
    "Immobilienmakler": „Jonathan Taksa DRE Nr. 01366169, Remax Gewerbe- und Investmentimmobilien“,
    "Immobilienbilder": [
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/915e6f92eea944a2a0debba76b13da55-full.webp",
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/1c7c779b8ea4bbb2396b69931ae0e08d-full.webp",
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/8b2ba082406829e89976e4011eaf1b1e-full.webp"
    ],
    "Eigenschaftslink": „110 N Kings Rd, Los Angeles, CA 90048“
  },
  {
    "Immobilienpreis": "$ 1,499,999",
    "Adresse der Immobilie": „245 Windward Ave, Venice, CA 90291“,
    "Grundstücksgröße": "1,332 m²",
    "Schlafzimmer zählen": "4bd",
    "Bäder zählen": "3ba",
    "Immobilienmakler": „Nicholas Hedberg DRE # 02016456, KW Advisors“,
    "Immobilienbilder": [
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/02ae27dc84e684f8e843b931d3086040-full.webp",
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/c5ba854452c3f0705e34ae442e9c5f41-full.webp",
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/8b4ad6000af4e365477c196f51eeb19f-full.webp"
    ],
    "Eigenschaftslink": „245 Windward Ave, Venice, CA 90291“
  },
  {
    "Immobilienpreis": "$ 2,161,000",
    "Adresse der Immobilie": „10425 Avalon Blvd, Los Angeles, CA 90003“,
    "Grundstücksgröße": null,
    "Schlafzimmer zählen": null,
    "Bäder zählen": null,
    "Immobilienmakler": „Dario Svidler DRE # 01884474, Keller Williams Beverly Hills“,
    "Immobilienbilder": [
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/bdb5e983a8cb57a0f2ad8a5b036d6424-full.webp",
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/6a3b35961617885210eafabc768273a1-full.webp",
      "https://www.trulia.com/pictures/thumbs_4/zillowstatic/fp/c0cf746206d1ce3b973f7613b6967f20-full.webp"
    ],
    "Eigenschaftslink": „10425 Avalon Blvd, Los Angeles, CA 90003“
  },
  ..... mehr
]

15. Seitennummerierung handhaben und Daten speichern

Unsere Reise mit dem Scraping von Trulia geht weiter, wobei wir uns mit zwei entscheidenden Aspekten befassen: der Handhabung der Paginierung für den Zugriff auf mehrere Suchergebnisseiten und dem Speichern der Scraped-Daten in einer praktischen Excel-Datei.

Umgang mit Paginierung

Trulia verwendet häufig Paginierung, um eine große Anzahl von Suchergebnissen anzuzeigen. Wir müssen systematisch durch diese Seiten navigieren.

Handhabung der Paginierung der Trulia-Website

Trulia verwendet eine spezielle pfadbasierte Methode, bei der jeder Seite eine fortlaufende Nummer zugewiesen wird. Die erste Seite hat beispielsweise den Pfad /1_p/, die zweite Seite verwendet /2_p/, Und so weiter.

Hier ist eine Funktion zum Verwalten der Seitennummerierung und Abrufen von HTML-Inhalten für eine bestimmte Seite:

1
2
3
4
5
6
7
8
9
10
11
12
13
# Funktion zum Abrufen von HTML-Inhalten mit Trulias Paginierung
def fetch_html_with_pagination(Basis-URL, Seitennummer):
    versuchen:
        # Erstellen Sie die URL mit Paginierungspfad
        Seiten-URL = f"{base_url}/{Seitenzahl}_P/"

        # HTML-Inhalte mit der Crawlbase abrufen Crawling API
        html_content = make_crawlbase_request(Seiten-URL)

        Rückkehr HTML-Inhalt
    ausgeschlossen Exception as e:
        drucken(f"Beim Abrufen von HTML mit Seitennummerierung ist ein Fehler aufgetreten: {str(e)}")
        Rückkehr Keine

Speichern von Scraped-Daten in einer Excel-Datei

Nachdem wir mehrere Seiten gescrapt haben, ist es wichtig, unsere hart erarbeiteten Daten zu speichern. So können wir das mit dem pandas Bibliothek:

1
2
3
4
5
6
7
8
9
10
11
importieren Pandas as pd

def in Excel speichern(Daten, Dateipfad=„trulia_scraped_data.xlsx“):
    versuchen:
        # Erstellen Sie einen DataFrame aus den Scraped-Daten
        df = pd.DataFrame(Daten)
        # Speichern Sie den DataFrame in einer Excel-Datei
        df.to_excel(Dateipfad, Index=falsch)
        drucken(f"Daten erfolgreich gespeichert in {Dateipfad}")
    ausgeschlossen Exception as e:
        drucken(f"Beim Speichern der Daten in Excel ist ein Fehler aufgetreten: {str(e)}")

Integrieren von Paginierung und Speichervorgängen in das Skript

Integrieren wir nun diese Funktionen in unser bestehendes Skript aus dem vorherigen Abschnitt. Fügen Sie die obigen Funktionen in das Skript ein und ersetzen Sie die vorhandenen main Funktion mit dieser aktualisierten Version:

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
def Haupt-†
    # Geben Sie die Trulia SERP-URL an
    Basis-URL = „https://www.trulia.com/CA/Los_Angeles“

    # Initialisieren Sie eine leere Liste, um die Scraped-Ergebnisse zu speichern
    scraped_results = []

    # Definieren Sie die Anzahl der Seiten, die Sie scrapen möchten
    Anzahl der zu scrapenden Seiten = 3  # Bei Bedarf anpassen

    # Durchlaufe jede Seite
    
für Seitennummer in Angebot(1, Anzahl_zu_scrapender_Seiten + 1):

        # HTML-Inhalt abrufen
        html_content = fetch_html_with_pagination(Basis-URL, Seitenzahl)

        # Trulia-Eintrag scrapen
        trulia_listings = scrape_trulia_listings(html_Inhalt)

        # Überprüfen Sie, ob trulia_listings leer ist
        if nicht trulia_listings:
            drucken(f"Fehler beim Scrapen der Trulia-Einträge für die Seite {Seitenzahl}.")
            fortsetzen

        
für trulia_listing in trulia_listings:

            # Einzelne Details scrapen
            Preis = Scrape_Trulia_Preis(Trulia_Listing)
            Adresse = Scrape_Trulia_Adresse(Trulia_Listing)
            Größe = Scrape_Trulia_Property_Größe(Trulia_Listing)
            Schlafzimmer = scrape_trulia_property_bedrooms_count(trulia_listing)
            Bäder = scrape_trulia_property_baths_count(trulia_listing)
            Agent = scrape_trulia_property_agent(Trulia-Auflistung)
            Bilder = scrape_trulia_images(trulia_listing)
            Link = Scrape_Trulia_Eigenschaftsseitenlink(Trulia_Eintrag)

            # Ergebnisse an die Liste anhängen
            result_dict = {
                'Immobilienpreis': Preis,
                'Adresse der Immobilie': Adresse,
                'Eigenschaftsgröße': Größe,
                „Schlafzimmer zählen“: Schlafzimmer,
                'Bäder zählen': Bäder,
                'Immobilienmakler': Vertreter,
                „Immobilienbilder“: Bilder,
                'Eigenschaftslink': Verknüpfung
            }
            scraped_results.append(Ergebnis_dict)

    # Gespeicherte Daten in Excel speichern
    in Excel speichern (gescrapte Ergebnisse, „trulia_scraped_data.xlsx“)

trulia_scraped_data.xlsx Schnappschuss:

trulia_scraped_data.xlsx Schnappschuss

Dieses integrierte Skript übernimmt nun nahtlos die Seitennummerierung und speichert die ausgelesenen Trulia-Daten in einer Excel-Datei. Viel Spaß beim Auslesen und bei der Datenverarbeitung!

16. Letzte Gedanken

Das Scraping von Trulia nach Immobiliendaten erfordert eine strategische Mischung aus Einfachheit und Effektivität. Während traditionelle Ansätze ihre Vorteile haben, ist die Integration der Crawlbase Crawling API steigert Ihre Scraping-Bemühungen. Verabschieden Sie sich von üblichen Herausforderungen und begrüßen Sie eine nahtlose, zuverlässige und skalierbare Lösung mit der Crawlbase Crawling API zum Trulia-Scraping.

Für diejenigen, die ihren Horizont erweitern und das Scraping von Daten von verschiedenen Plattformen erkunden möchten, warten unsere aufschlussreichen Anleitungen darauf, von Ihnen erkundet zu werden:

📜 So scrapen Sie Zillow
📜 Wie man Airbnb scrapt
📜 Wie man Booking.com scrapt
📜 So scrapen Sie Expedia

Sollten Sie auf Hindernisse stoßen oder Hilfe benötigen, unsere engagiertes Team steht bereit, um Sie bei der Navigation durch die dynamische Welt der Immobiliendaten zu unterstützen.

17. Häufig gestellte Fragen (FAQs)

Obwohl die Rechtmäßigkeit von Web Scraping variieren kann, ist es wichtig, die Servicebedingungen von Trulia zu überprüfen, um die Einhaltung sicherzustellen. Trulia hat möglicherweise spezifische Richtlinien für die Datenextraktion von seiner Plattform. Es ist ratsam, die Bedingungen und Richtlinien der Website zu respektieren, die erforderlichen Genehmigungen einzuholen und Web Scraping verantwortungsbewusst zu verwenden.

F: Warum Trulia scrapen?

Das Scraping von Trulia liefert wertvolle Immobiliendaten, die für verschiedene Zwecke genutzt werden können, wie etwa Marktanalysen, Immobilientrends und Wettbewerbseinblicke. Durch das Extrahieren von Daten aus Trulia können Benutzer umfassende Informationen über Immobilienangebote, Preise und Ausstattungen sammeln und so Käufern, Verkäufern und Immobilienfachleuten fundierte Entscheidungen ermöglichen.

Warum Trulia scrapen?

F: Was können Sie von Trulia scrapen?

Trulia bietet eine umfangreiche Quelle für Immobilieninformationen und ermöglicht das Scrapen von Objektdetails, Objektbeschreibungen, Adressen, Preisdaten und mehr. Darüber hinaus können Benutzerbewertungen, Bewertungen und Bilder zu Objekten extrahiert werden. Die Vielseitigkeit des Scrapings von Trulia ermöglicht es Benutzern, ihre Datenextraktion an spezifische Anforderungen anzupassen.

Was kann man von Trulia kratzen

F: Was sind die besten Möglichkeiten zum Scrapen von Trulia?

Der beste Ansatz zum Scrapen von Trulia besteht in der Nutzung der dedizierten API mit IP-Rotation wie Crawlbase Crawling API für eine effiziente und zuverlässige Datenextraktion. Durch die Verwendung eines seriösen Scraping-Dienstes stellen Sie eine reibungslosere Handhabung dynamischer Inhalte, eine effektive Paginierung und die Einhaltung ethischer Scraping-Praktiken sicher. Die Einbindung von Python-Bibliotheken neben Crawlbase-Diensten verbessert den Scraping-Prozess.