Das Sammeln von sauberen, verwendbaren Daten ist die Grundlage für ein erfolgreiches Web -Scraping -Projekt. Webdaten werden jedoch häufig mit Inkonsistenzen, Duplikaten und irrelevanten Inhalten gefüllt, wodurch es schwierig ist, mit der Quelle direkt aus der Quelle zu arbeiten.
Hier kommt das Kombinieren von Scraperapi mit Datenreinigungsleitungen ins Spiel. Scraperapi hilft Ihnen, Daten aus Websites zuverlässig zu extrahieren-selbst diejenigen mit komplexen Anti-Scraping-Schutzmaßnahmen-, während die Datenwerkzeuge von Python es einfach machen, diese Daten zur Verwendung zu reinigen, zu strukturieren und diese vorzubereiten.
In diesem Leitfaden lernen Sie:
- Richten Sie das Schafera zum Web -Scraping ein
- Verwenden Sie ETL -Techniken (Extrakt, Transformation, Last), um Ihre Daten zu reinigen und zu organisieren
- Integrieren Sie diese Tools in einen schnell, flexiblen und skalierbaren Workflow
Bereit? Fangen wir an!
Was ist ETL?
ETL steht für Extrahieren, transformieren, laden. Es handelt sich um ein Datenverarbeitungsframework, mit dem Daten aus einer oder mehreren Quellen verschoben, sie reinigen und in einem System gespeichert werden können, in dem sie analysiert werden können. Dieser Prozess ist wichtig, um große Datenmengen aus verschiedenen Quellen zu behandeln, diese auf die Berichterstattung und die fundierten Entscheidungsfindung vorzubereiten.
Die drei Stufen von ETL
- Extrakt: In dieser ersten Phase werden Rohdaten aus seiner Quelle gesammelt. In unserem Fall bedeutet dies, Websites zu kratzen. Dies kann schwierig sein, da Websites häufig Anti-Scraping-Maßnahmen wie IP-Verbote, Captchas und dynamisches Inhaltsladen durch JavaScript implementieren. Um diese Herausforderungen zu verwalten und den Extraktionsprozess zu optimieren, verwenden wir Scraperapi, ein Tool, das die Datenerfassung im Maßstab vereinfacht und automatisiert.
- Verwandeln: Sobald Daten extrahiert sind, ist sie oft unordentlich oder inkonsistent. Die reale Reinigung erfolgt in der Transformationsphase: Die Daten werden validiert, standardisiert und in ein verwendbares Format umgebaut. Dies ist ein entscheidender Schritt zur Gewährleistung der Datenqualität und -konsistenz.
- Laden: Schließlich werden die gereinigten und transformierten Daten in ein Speichersystem geladen. Abhängig vom Projekt kann dies eine CSV -Datei, eine relationale Datenbank (wie PostgreSQL oder MySQL), eine NOSQL -Datenbank (wie MongoDB), ein Data Warehouse (wie BigQuery, Redvershift oder Snowflake) oder sogar einen Data Lake sein. Wir werden dieses Tutorial einfach behalten und die Daten in eine CSV -Datei laden.
Scraperapi und Python für ETL
Web-Craped-Daten sind häufig chaotisch, inkonsistent und unstrukturiert-noch nicht bereit für die Analyse oder Entscheidungsfindung. Hier wird ETL essentiell. Es bringt Struktur, Sauberkeit und Zuverlässigkeit in chaotische Webdaten mit, was sie wertvoller macht.
Lassen Sie uns aufschlüsseln, wie dies im Kontext von Immobilienlisten funktioniert:
- Extrakt: Ziehen Sie den Scraperapi aus, um RAW -HTML von mehreren Immobilien -Website -Seiten zu ziehen. Scraperapi behandelt die härtesten Teile der Web-Scraping-IP-Rotation, Spoofing, Captcha-Lösung und sogar das Rendering von JavaScript-.
- Verwandeln: Mit Bibliotheken wie
BeautifulSoupUndPandasSie können Ihre Daten mithilfe von Python reinigen und standardisieren:- Preisfelder analysieren, Währungssymbole entfernen und Werte in ein numerisches Format konvertieren.
- Standardisieren Sie den inkonsistenten Text (z. B. „3 BDR“, „drei Betten“) in ein einzelnes Format wie (z. B. 3).
- Normalisieren Sie die Quadratmeterzahl auf eine konsistente Einheit und einen konsistenten Datentyp.
- Behandeln Sie fehlende Werte für Funktionen wie Balkonen oder Garagen.
- Identifizieren und entfernen Sie doppelte Listen, die aufgrund häufiger Site -Updates angezeigt werden können.
- Laden:
Sobald die Daten gereinigt und transformiert sind, verwenden Sie Pandas, um sie in ein strukturiertes Format wie ein CSV zur Berichterstattung oder -analyse zu exportieren oder direkt in eine Datenbank für Langzeitspeicher und Abfragen zu laden.
Mit Python und Scraperapi zusammen haben Sie ein leistungsstarkes ETL -Toolkit:
- Scraperapi vereinfacht und verhärtet die Extraktphase.
- Mit seinen reichhaltigen Datenhandlungsfunktionen deckt Python die Transformation und Belastung mit Flexibilität und Präzision ab.
Diese ETL -Pipeline garantiert, dass die von Ihnen abgekratzten Daten präzise, konsistent und für die Verwendung vorbereitet sind, unabhängig davon, ob Sie Markttrends analysieren oder ein Immobilien -Dashboard erstellen.
Projektanforderungen
Stellen Sie vor dem Eintauchen in die Integration sicher, dass Sie Folgendes haben:
1. Ein Schaferapi -Konto: Melden Sie sich auf der Scraperapi -Website an, um Ihren API -Schlüssel zu erhalten. Scraperapi behandelt Proxy -Rotation, Captcha -Lösung und JavaScript -Rendering, wodurch die Extraktionsphase A -Brise wird. Sie erhalten 5.000 kostenlose API-Credits, wenn Sie sich für eine siebentägige Testversion anmelden, wenn Sie fertig sind.
2. Eine Python -Umgebung: Stellen Sie sicher, dass Python (empfohlene Version 3.7+) in Ihrem System installiert ist. Sie müssen auch wichtige Bibliotheken installieren:
requests: Für HTTP -Anfragen zum Schäfer.beautifulsoup4: Zum Analysen von HTML- und XML -Inhalten.pandas: Für Datenmanipulation und Reinigung.python-dotenv: So laden Sie Ihre Anmeldeinformationen aus Ihrer .Env -Datei und verwalten Sie Ihre API -Taste sicher.lxml(Optional, aber empfohlen): Ein schneller und effizienter XML- und HTML -Parser, den BeautifulSup verwenden kann.
Sie können sie mit PIP mit diesem Befehl installieren:
pip install requests beautifulsoup4 pandas lxml python-dotenv
3. Grundlegendes Web -Scraping -Wissen: Ein grundlegendes Verständnis der HTML -Struktur, der CSS -Selektoren und der Funktionsweise von Web -Scraping ist von Vorteil.
4. Ein IDE- oder Code -Editor: Wie VS -Code, Pycharm oder Jupyter -Notizbuch zum Schreiben und Ausführen Ihrer Python -Skripte.
Tl; dr;
Für diejenigen, die es eilig haben, ist hier der volle Schaber, den wir bauen werden:
import os
import re
import requests
import pandas as pd
from bs4 import BeautifulSoup
from dotenv import load_dotenv
# === Load environment variables from .env file ===
load_dotenv()
SCRAPER_API_KEY = os.getenv('SCRAPER_API_KEY')
IDEALISTA_URL = os.getenv('IDEALISTA_URL')
SCRAPER_API_URL = f"http://api.scraperapi.com/?api_key={SCRAPER_API_KEY}&url={IDEALISTA_URL}"
# === Extract ===
def extract_data(url):
response = requests.get(url)
extracted_data = ()
if response.status_code == 200:
soup = BeautifulSoup(response.text, 'html.parser')
listings = soup.find_all('article', class_='item')
for listing in listings:
title = listing.find('a', class_='item-link').get('title')
price = listing.find('span', class_='item-price').text.strip()
item_details = listing.find_all('span', class_='item-detail')
bedrooms = item_details(0).text.strip() if item_details and item_details(0) else "N/A"
area = item_details(1).text.strip() if len(item_details) > 1 and item_details(1) else "N/A"
description = listing.find('div', class_='item-description')
description = description.text.strip() if description else "N/A"
tags = listing.find('span', class_='listing-tags')
tags = tags.text.strip() if tags else "N/A"
images = (img.get("src") for img in listing.find_all('img')) if listing.find_all('img') else ()
extracted_data.append({
"Title": title,
"Price": price,
"Bedrooms": bedrooms,
"Area": area,
"Description": description,
"Tags": tags,
"Images": images
})
else:
print(f"Failed to extract data. Status code: {response.status_code}")
return extracted_data
# === Transform ===
def transform_data(data):
df = pd.DataFrame(data)
df('Price') = (
df('Price')
.str.replace('€', '', regex=False)
.str.replace(',', '', regex=False)
.str.strip()
.astype(float)
)
def extract_bedrooms(text):
match = re.search(r'\d+', text)
return int(match.group()) if match else None
df('Bedrooms') = df('Bedrooms').apply(extract_bedrooms)
df('Area') = (
df('Area')
.str.replace('m²', '', regex=False)
.str.replace(',', '.', regex=False)
.str.strip()
.astype(float)
)
df.dropna(subset=('Price', 'Bedrooms', 'Area'), inplace=True)
df = df(df('Bedrooms') == 3)
return df
# === Load ===
def load_data(df, filename='three_bedroom_houses.csv'):
df.to_csv(filename, index=False)
print(f"Saved {len(df)} listings to {filename}")
# === Main pipeline ===
def main():
print("Starting ETL pipeline for Idealista listings...")
raw_data = extract_data(SCRAPER_API_URL)
if not raw_data:
print("No data extracted. Check your API key or target URL.")
return
print(f"Extracted {len(raw_data)} listings.")
cleaned_data = transform_data(raw_data)
print(f"{len(cleaned_data)} listings after cleaning and filtering.")
load_data(cleaned_data)
if __name__ == "__main__":
main()
Möchten Sie sehen, wie wir es gebaut haben? Lesen Sie weiter!
Bau einer Immobilien -ETL -Pipeline mit Schakerapi und Python
In diesem Abschnitt erstellen wir eine funktionierende ETL -Pipeline, die im Immobilienlisten von Idealista unter Verwendung von Scraperapi kratzt, die Daten mit Python reinigt und in einer strukturierten CSV -Datei speichert. Wir werden jeden Teil des Prozesses durchgehen – die Daten extrahieren, sie in ein verwendbares Format verwandeln und sie für die Analyse laden -. Sie haben also einen vollständigen und wiederverwendbaren Workflow am Ende.
Schritt 1: Extrahieren: Verwenden von Scraperapi
Die meisten Immobilienwebsites sind dafür bekannt, Schaber zu blockieren und Daten in einer aussagekräftigen Ausweitung herausfordernd zu machen. Aus diesem Grund haben wir unsere geschickt get() Anfragen über Scraperapi, die die Anti-Kritik-Mechanismen von Idealista ohne komplizierte Problemumgehungen effektiv umgehen.
Für diesen Leitfaden aktualisieren wir ein vorhandenes Immobilienprojekt für Scraperapi, um die Integration zu demonstrieren. Hier finden Sie den kompletten Leitfaden zum Scraping Idealista mit Python.
import json
from datetime import datetime
import requests
from bs4 import BeautifulSoup
scraper_api_key = 'YOUR_SCRAPERAPI_KEY' # Replace with your ScraperAPI key
idealista_query = "https://www.idealista.com/en/venta-viviendas/barcelona-barcelona/"
scraper_api_url = f'http://api.scraperapi.com/?api_key={scraper_api_key}&url={idealista_query}'
response = requests.get(scraper_api_url)
extracted_data = ()
# Check if the request was successful (status code 200)
if response.status_code == 200:
# Parse the HTML content using BeautifulSoup
soup = BeautifulSoup(response.text, 'html.parser')
# Extract each house listing post
house_listings = soup.find_all('article', class_='item')
# Create a list to store extracted information
# Loop through each house listing and extract information
for index, listing in enumerate(house_listings):
# Extracting relevant information
title = listing.find('a', class_='item-link').get('title')
price = listing.find('span', class_='item-price').text.strip()
# Find all div elements with class 'item-detail'
item_details = listing.find_all('span', class_='item-detail')
# Extracting bedrooms and area from the item_details
bedrooms = item_details(0).text.strip() if item_details and item_details(0) else "N/A"
area = item_details(1).text.strip() if len(item_details) > 1 and item_details(1) else "N/A"
description = listing.find('div', class_='item-description').text.strip() if listing.find('div', class_='item-description') else "N/A"
tags = listing.find('span', class_='listing-tags').text.strip() if listing.find('span', class_='listing-tags') else "N/A"
# Extracting images
image_elements = listing.find_all('img')
images = (img.get("src") for img in image_elements) if image_elements else ()
# Store extracted information in a dictionary
listing_data = {
"Title": title,
"Price": price,
"Bedrooms": bedrooms,
"Area": area,
"Description": description,
"Tags": tags,
"Images": images
}
# Append the dictionary to the list
extracted_data.append(listing_data)
Der obige Code kratzt und analysiert Immobilienlisten aus Idealista mit Scraperapi und BeautifulSoup. Es beginnt mit dem Konfigurieren von Schäfer mit Ihrer Schaferapi -Taste und der Ziel -URL und sendet dann eine HTTP -Anforderung an die URL. Wenn die Anfrage erfolgreich ist, ist die HTML mit BeautifulSoup analysiert, und das Skript findet alle
"item" (die Eigenschaftenlisten darstellen). Anschließend durchläuft jede Liste die wichtigsten Details – Titel, Preis, Anzahl der Schlafzimmer, Bereich, Beschreibung, Tags und Bild -URLs.Schritt 2: Transformation der Daten (Datenreinigung)
Nach dem Extrahieren von Rohdaten aus Idealista besteht der nächste Schritt darin, sie zu reinigen und vorzubereiten. Um diese Daten nützlicher zu machen, werden wir verwenden pandaseine leistungsstarke Python -Bibliothek für die Datenanalyse. Wenn Sie noch nie benutzt haben pandas Stellen Sie sich das wie Excel vor – nur in Python und flexibler.
In Schritt 1 haben wir jede Auflistung in einem Wörterbuch gespeichert und diese Wörterbücher zu einer Liste mit dem Titel hinzugefügt extracted_data. So könnte diese Liste aussehen:
(
{
"Title": "Spacious apartment in central Barcelona",
"Price": "€350,000",
"Bedrooms": "3 bdr",
"Area": "120 m²",
"Description": "...",
"Tags": "Luxury",
"Images": (...)
},
...
)
Jetzt werden wir PANDAS verwenden, um diese Liste in einen strukturierten Datenfream (ein tabellähnliches Objekt) umzuwandeln und dann jede Spalte Schritt für Schritt zu reinigen.
import pandas as pd
# Convert raw listing data to a DataFrame
df = pd.DataFrame(three_bedroom_listings)
# View the raw data
print(df.head())
pd.DataFrame(...)Erstellt einen Datenrahmen aus einer Liste von Wörterbüchern. Jedes Wörterbuch wird zur Reihe; Jeder Schlüssel wird zur Spalte..head()Zeigt die ersten fünf Zeilen an – nützlich für die Überprüfung von Struktur und Datentypen.
Die Preiswerte sind Zeichenfolgen wie "€350,000". Wir entfernen Symbole und formatieren, um sie in numerische Werte umzuwandeln.
df('Price') = (
df('Price')
.str.replace('€', '', regex=False) # Remove the euro symbol
.str.replace(',', '', regex=False) # Remove comma separators
.str.strip() # Remove leading/trailing whitespace
.astype(float) # Convert strings to float
)
print(df('Price').head()) # Display the first few prices to verify conversion
.str.replace(old, new)Modifiziert die Zeichenfolgenwerte in einer Spalte..str.strip()Entfernt unnötige Räume von beiden Enden..astype(float)ändert den Spaltentyp von String in Float, sodass wir später numerische Operationen ausführen können.
Listings können Text wie "3 bdr" oder "two beds". Wir werden nur die Anzahl der Schlafzimmer als Ganzzahl mit einer Regex -Funktion mit extrahieren .apply().
import re
def extract_bedrooms(text):
match = re.search(r'\d+', text) # Find the first sequence of digits
return int(match.group()) if match else None
df('Bedrooms') = df('Bedrooms').apply(extract_bedrooms)
print(df('Bedrooms').head()) # Display the first few bedroom counts to verify conversion
.apply()Fährt eine Funktion in jedem Element in der Spalte aus.re.search(r'\d+', text)sucht nach der ersten Gruppe von Ziffern.
Dies reinigt und standardisiert die Zahl der Schlafzimmer in Ganzzahlen. Die Werte umfassen Einheiten wie "120 m²". Wir werden diese entfernen und in Schwimmer konvertieren.
df('Area') = (
df('Area')
.str.replace('m²', '', regex=False) # Remove unit
.str.replace(',', '.', regex=False) # Convert comma to dot for decimal values
.str.strip() # Clean up whitespace
.astype(float) # Convert to float
)
print(df('Area').head()) # Display the first few areas to verify conversion
Dies stellt sicher, dass alle Werte in der Spalte „Fläche“ konsistente numerische Typen sind, damit wir Metriken wie Preis pro Quadratmeter sortieren, filtern oder berechnen können.
Einige Listen fehlen möglicherweise wesentliche Werte. Wir werden Zeilen mit fehlenden Daten in Schlüsselspalten fallen lassen. Sie können auswählen, welche Spalten von entscheidender Bedeutung sind und keine fehlenden Werte haben sollten.
df.dropna(subset=('Price', 'Bedrooms', 'Area'), inplace=True)
.dropna()Entfernt Zeilen mit NAN (fehlenden) Werten.- Der
subsetArgument beschränkt diese Überprüfung auf bestimmte Spalten; Bei Bedarf können Sie hier andere Spalten hinzufügen. inplace=TrueÄndert den Datenrahmen direkt, ohne ihn neu zuweisen zu müssen.
Um nur mit Listings mit genau 3 Schlafzimmern zu arbeiten (optional):
df = df(df('Bedrooms') == 3)
df(condition)Filterreihen basierend auf einer Bedingung.- Hier prüfen wir, wo die Spalte „Schlafzimmer“ 3 entspricht, und aktualisiert DF, um nur diese Zeilen einzuschließen.
Zu diesem Zeitpunkt sind Ihre Daten ähnlich wie folgt strukturiert:
| Titel | Preis | Schlafzimmer | Bereich | … |
|---|---|---|---|---|
| „Moderne Wohnung in Eixample“ | 310000.00 | 3 | 95.0 | … |
| „Loft mit Terrasse in Gracia“ | 275000.00 | 2 | 82.0 | … |
Dieser gereinigte Datenrahmen ist jetzt für Analyse oder Export bereit. Im nächsten Schritt laden wir es in eine CSV -Datei.
Schritt 3: Laden Sie gereinigte Daten in CSV (Speichern)
Wenn Ihre Daten jetzt in einem Pandas -Datenframe gereinigt und strukturiert sind, besteht der letzte Schritt darin, sie bestehen zu können, was bedeutet, dass Sie ihn irgendwo speichern, damit sie später wiederverwendet, gemeinsam genutzt oder analysiert werden können.
Die CSV-Datei ist das häufigste und anfängerfreundlichste Format zum Speichern von tabellarischen Daten. Es handelt sich um eine einfache Textdatei, in der jede Zeile eine Zeile ist und Commas jede Spalte trennen. Die meisten Tools – Exzel, Google -Blätter, Datenvisualisierungstools und Programmiersprachen – können CSV -Dateien effizient öffnen und verarbeiten.
Sie können Ihren Datenrahmen in einem CSV mit nur einer Codezeile speichern:
# Save the cleaned DataFrame to a CSV file
df.to_csv('three_bedroom_houses.csv', index=False)
df.to_csv(...)ist eine Pandas -Methode, die Ihren Datenrahmen in eine CSV -Datei schreibt.'three_bedroom_houses.csv'ist der Dateiname, der erstellt (oder überschrieben) wird.index=FalseerzähltpandasSchreiben Sie den DataFrame -Index (Zeilennummern) nicht in die Datei, wodurch er sauber bleibt, es sei denn, Sie benötigen ihn ausdrücklich.
Sobald dies erledigt ist, sehen Sie eine neue Datei in Ihrem Arbeitsverzeichnis (in dem Ihr Skript ausgeführt wird). So könnte ein paar Zeilen dieser Datei aussehen:
Title,Price,Bedrooms,Area,Description,Tags,Images
"Flat / apartment in calle de Bailèn, La Dreta de l'Eixample, Barcelona",675000.0,3,106.0,"Magnificent and quiet brand new refurbished flat in Eixample.
This ready-to-live-in flat enjoys a fantastic location very close to the popular Paseo Sant Joan and the pedestrian street Consell de Cent. It is a very pleasant urban environment in which to live in the neighbourhood, with numerous services, shops, restau",N/A,"('https://img4.idealista.com/blur/480_360_mq/0/id.pro.es.image.master/dd/d0/85/1326281103.jpg', 'https://st3.idealista.com/b1/b8/d4/bcn-advisors.gif')"
Sie können es öffnen in:
- Excel: Doppelklicken Sie einfach auf die Datei.
- Google -Blätter: Laden Sie die Datei hoch und importieren Sie sie als Tabelle.
- Ein weiteres Python -Skript: Verwenden
pd.read_csv() - Visualisierungstools: Wie Power BI, Tableau oder sogar Jupyter -Notizbücher.
Wenn Sie später mit einem größeren Datensatz arbeiten oder eine bessere Leistung benötigen, sollten Sie in einer Datenbank speichern. Aber im Moment ist CSV ideal.
Schritt 4: Fertigstellung der ETL -Pipeline
Nachdem Ihr Schaber funktioniert und Ihre Daten sauber sind, ist es Zeit, Ihren Code in eine ordnungsgemäße ETL -Pipeline zu verwandeln. Dies erleichtert es, zu pflegen, wiederzuverwenden, zu planen oder zu erweitern. Wir werden hier zwei Dinge tun:
1. Modularisieren Sie das Skript in Extrakt-, Transformations- und Lastfunktionen
2. Verschieben python-dotenv Paket
Diese endgültige Version ist produktionsfreundlich, sicher und einfach zu bauen. First, installieren python-dotenv Wenn Sie es noch nicht haben:
pip install python-dotenv
Als nächstes erstellen Sie a .env Datei in Ihrem Projektverzeichnis und fügen Sie sensible Informationen hinzu:
SCRAPER_API_KEY=your_scraperapi_key_here
IDEALISTA_URL=https://www.idealista.com/en/venta-viviendas/barcelona-barcelona/
Hier ist Ihr endgültiges Pipeline -Skript, wobei der Code umstrukturiert und in separaten Methoden organisiert ist:
import os
import re
import requests
import pandas as pd
from bs4 import BeautifulSoup
from dotenv import load_dotenv
# === Load environment variables from .env file ===
load_dotenv()
SCRAPER_API_KEY = os.getenv('SCRAPER_API_KEY')
IDEALISTA_URL = os.getenv('IDEALISTA_URL')
SCRAPER_API_URL = f"http://api.scraperapi.com/?api_key={SCRAPER_API_KEY}&url={IDEALISTA_URL}"
# === Extract ===
def extract_data(url):
response = requests.get(url)
extracted_data = ()
if response.status_code == 200:
soup = BeautifulSoup(response.text, 'html.parser')
listings = soup.find_all('article', class_='item')
for listing in listings:
title = listing.find('a', class_='item-link').get('title')
price = listing.find('span', class_='item-price').text.strip()
item_details = listing.find_all('span', class_='item-detail')
bedrooms = item_details(0).text.strip() if item_details and item_details(0) else "N/A"
area = item_details(1).text.strip() if len(item_details) > 1 and item_details(1) else "N/A"
description = listing.find('div', class_='item-description')
description = description.text.strip() if description else "N/A"
tags = listing.find('span', class_='listing-tags')
tags = tags.text.strip() if tags else "N/A"
images = (img.get("src") for img in listing.find_all('img')) if listing.find_all('img') else ()
extracted_data.append({
"Title": title,
"Price": price,
"Bedrooms": bedrooms,
"Area": area,
"Description": description,
"Tags": tags,
"Images": images
})
else:
print(f"Failed to extract data. Status code: {response.status_code}")
return extracted_data
# === Transform ===
def transform_data(data):
df = pd.DataFrame(data)
df('Price') = (
df('Price')
.str.replace('€', '', regex=False)
.str.replace(',', '', regex=False)
.str.strip()
.astype(float)
)
def extract_bedrooms(text):
match = re.search(r'\d+', text)
return int(match.group()) if match else None
df('Bedrooms') = df('Bedrooms').apply(extract_bedrooms)
df('Area') = (
df('Area')
.str.replace('m²', '', regex=False)
.str.replace(',', '.', regex=False)
.str.strip()
.astype(float)
)
df.dropna(subset=('Price', 'Bedrooms', 'Area'), inplace=True)
df = df(df('Bedrooms') == 3)
return df
# === Load ===
def load_data(df, filename='three_bedroom_houses.csv'):
df.to_csv(filename, index=False)
print(f"Saved {len(df)} listings to {filename}")
# === Main pipeline ===
def main():
print("Starting ETL pipeline for Idealista listings...")
raw_data = extract_data(SCRAPER_API_URL)
if not raw_data:
print("No data extracted. Check your API key or target URL.")
return
print(f"Extracted {len(raw_data)} listings.")
cleaned_data = transform_data(raw_data)
print(f"{len(cleaned_data)} listings after cleaning and filtering.")
load_data(cleaned_data)
if __name__ == "__main__":
main()
Mit diesem letzten Schritt ist Ihr Schaber jetzt:
- Modular und einfach zu aktualisieren
- Sicher, mit API -Schlüssel, die sicher in Umgebungsvariablen gespeichert sind
- Bereit zu skalieren, zu automatisieren oder in größere Datenworkflows einzuschließen
Sie haben jetzt einen wiederverwendbaren, skalierbaren Workflow zum Schaber und Analysieren von Immobilienlisten!
Anwendungsfälle für Schakerapi und Pythons Datenreinigungsintegration
Nachdem Sie gesehen haben, wie Scraperapi und Python zusammenarbeiten, um Immobiliendaten zu extrahieren und zu reinigen, lassen Sie uns untersuchen, wie diese leistungsstarke Kombination in Branchen verwendet werden kann. Der ETL-Workflow-Extrahieren, Transformation, Last-ist flexibel und skalierbar, was ihn für viele datengesteuerte Projekte nützlich macht.
Hier sind mehrere praktische Anwendungen, bei denen sich diese Integration auszeichnet:
1. Sentimentanalyse: Sie können untersuchen, wie sich die Sprache auf das Interesse des Käufers auswirkt, indem Sie Immobilienbeschreibungen oder Benutzerbewertungen abkratzen. Nach dem Reinigen des Textes mit Python können die Tools für die Sentimentanalyse wie TextBlob oder Vader den Ton als positiv, neutral oder negativ bewerten. Dies ermöglicht es zu sehen, ob Auflistungen, die ansprechende Begriffe wie „geräumig“ oder „modern“ verwenden, dazu neigen, schneller zu verkaufen oder höhere Preise zu beherrschen.
2. Trendüberwachung: Durch das regelmäßige Ausführen Ihres Schabers wird ein Datensatz erstellt, in dem sich die Immobilienpreise und -funktionen im Laufe der Zeit ändern. Es ist einfacher, Trends zu visualisieren und zu verfolgen, wie sich bestimmte Marktsegmente weiterentwickeln, indem die Daten um wichtige Attribute wie Ort, Anzahl der Schlafzimmer oder Immobilientyp strukturiert werden.
3. Wettbewerbsforschung: Das Abkratzen von Auflistungen aus mehreren Immobilienplattformen bietet Ihnen einen direkten Überblick über die Preise und Positionen der Wettbewerber ähnlicher Immobilien. Mit standardisierten Daten können Sie Preisstrategien, die Auflistungsfrequenz und Funktionen zum Identifizieren von Marktlücken oder spezifischen Bereichen, in denen sich Ihr Angebot herausheben kann, vergleichen.
4. Community -Erkenntnisse: Durch das Sammeln von Daten aus Foren, Überprüfungsseiten oder Social -Media -Gesprächen kann ergeben, was Käufer und Mieter interessieren. Nach der Reinigung und Verarbeitung des Textes kann die Analyse gemeinsame Prioritäten aufdecken: die Nähe zu Schulen, Nachfrage nach Grünflächen oder Bedenken hinsichtlich von Lärm usw., die Entwicklungs- und Marketingentscheidungen beeinflussen können.
Einpacken
Durch die Integration von Scraperapi in die Datenverreinigungspipelines wird ein leistungsstarkes Setup für die Arbeit mit Webdaten erstellt. Scraperapi kümmert sich um die schwierigen Teile des Kratzens – wie Captchas, IP -Blöcke und JavaScript -Rendering -. Sie können also zuverlässig Daten extrahieren. Auf der anderen Seite hilft Ihnen Python dabei, diese Daten zu reinigen und zu organisieren und sicherzustellen, dass sie genau, konsistent und analysiert sind. Diese Kombination spart Zeit und erleichtert es, echte Erkenntnisse aus chaotischen, realen Daten zu erhalten.
In diesem Tutorial gingen wir durch den Prozess von:
- Extrahieren Immobilienauflistungen von Idealista mit dem Scraperapi
- Verwandeln Die Daten durch Standardisierung von Datentypen, Entfernen von unerwünschten Zeichen und leeren Werten und Filterung für Listen mit drei Schlafzimmern.
- Laden Die gereinigten Daten in eine strukturierte CSV -Datei für die einfache Freigabe und Analyse
Wenn Sie es für sich selbst ausprobieren möchten, können Sie sich für ein kostenloses Scraperapi -Konto anmelden und 5.000 API -Credits erhalten, um sofort mit dem Kratzen zu beginnen. Es ist eine großartige Möglichkeit, das Wasser zu testen und zu sehen, wie es in Ihre Datenworkflows passt.
Bis zum nächsten Mal, glücklich zu kratzen!
