Projekteinrichtung und Datenimport
Definieren Sie die Projektziele, laden Sie Daten aus einer CSV-Datei und einer SQLite-Datenbank, führen Sie die Quellen zusammen und prüfen Sie den kombinierten Datensatz vollständig.
Projekteinrichtung und Datenimport ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Ziel des Abschlussprojekts
In diesem Abschlussprojekt führen Sie alle Fähigkeiten aus dem Kurs zusammen — NumPy, Pandas, Visualisierung, statistische Tests, Datenbankanbindung und Pipeline-Design — und setzen sie in einem durchgängigen Workflow ein. Das Projekt simuliert eine typische Aufgabe aus der Praxis: Rohdaten aus zwei Quellen (einer CSV-Datei und einer Datenbanktabelle) einlesen, zusammenführen, die Datenqualität prüfen, fortgeschrittene KPIs berechnen, Trends visualisieren und einen aufbereiteten Bericht exportieren. Dies entspricht der täglichen Arbeit professioneller Datenanalysten in der Industrie.
Projektziele und KPIs festlegen
Bevor Sie auch nur eine einzige Codezeile schreiben, legen Sie die Projektziele und die Key Performance Indicators (KPIs) fest, die Sie berechnen werden. Dokumentieren Sie: Welche Geschäftsfrage beantworten Sie? Welche Datenquellen stehen Ihnen zur Verfügung? Welche Ausgabeformate werden benötigt? Für dieses Abschlussprojekt gilt: Analysieren Sie monatliche Umsatztrends nach Produktkategorie, berechnen Sie die Kundenbindung nach Kohorten, ermitteln Sie die Regionen mit der höchsten Gewinnmarge und exportieren Sie einen Bericht mit Visualisierungen. Ein klares Ziel verhindert eine schleichende Ausweitung des Projektumfangs und hält die Pipeline fokussiert.
# Project configuration — define goals upfront
CONFIG = {
'csv_path': 'data/orders_2024.csv',
'db_url': 'sqlite:///customer_db.sqlite',
'db_table': 'customers',
'output_dir': 'output/',
'report_path': 'output/report.md',
'analysis_year': 2024,
'top_n_regions': 5,
'rolling_window_days': 30
}
print('Project config loaded.')
print('Target KPIs: monthly revenue, cohort retention, top regions by margin')Daten aus einer CSV-Datei laden
Laden Sie die CSV-Datei mit den expliziten Argumenten dtype und parse_dates, um Fehler bei der Typinferenz zu vermeiden. In einem realen Projekt kann die CSV-Datei von einem anderen System mit abweichenden Konventionen exportiert worden sein — setzen Sie bei Bedarf encoding, sep und thousands. Überprüfen Sie sofort shape, dtypes und head(), um vor jeder Transformation sicherzustellen, dass das Laden korrekt war. Diese erste Prüfung deckt häufig Probleme mit der Zeichenkodierung, zusätzliche Kopfzeilen oder unerwartete Spaltennamen auf.
import pandas as pd
df_orders = pd.read_csv(
'data/orders_2024.csv',
dtype={
'order_id': 'int32',
'customer_id': 'int32',
'product_id': 'int32',
'quantity': 'int16',
'unit_price': 'float32',
'region': 'category',
'category': 'category'
},
parse_dates=['order_date'],
encoding='utf-8'
)
print(f'Orders loaded: {df_orders.shape}')
print(df_orders.dtypes)
print(df_orders.head(3))Daten aus der Datenbank laden
Die zweite Datenquelle ist die Kundentabelle in einer SQLite-Datenbank. Laden Sie mit einer SQL-SELECT-Anweisung nur die für die Analyse benötigten Spalten, statt die gesamte Tabelle einzulesen. Verknüpfen Sie die beiden Quellen über customer_id, um jede Bestellung um demografische Kundendaten anzureichern. Stellen Sie vor dem Zusammenführen sicher, dass die customer_id-Schlüssel in beiden Quellen denselben Datentyp haben — eine häufige Ursache für unbemerkt fehlschlagende Zusammenführungen ist der Vergleich eines Schlüssels vom Typ int32 mit einem Schlüssel vom Typ String.
import pandas as pd
import sqlalchemy as sa
engine = sa.create_engine('sqlite:///customer_db.sqlite')
df_customers = pd.read_sql_query(
'''
SELECT customer_id, customer_name, country,
acquisition_channel, signup_date
FROM customers
''',
con=engine,
dtype={'customer_id': 'int32'},
parse_dates=['signup_date']
)
print(f'Customers loaded: {df_customers.shape}')
print(df_customers.dtypes)
print(df_customers.head(3))Die beiden Quellen zusammenführen
Führen Sie Bestellungen über customer_id mit den Kundendaten zusammen und verwenden Sie dabei einen Left Join, damit alle Bestellungen erhalten bleiben, selbst wenn ein Kundendatensatz fehlt. Prüfen Sie nach dem Zusammenführen, wie viele Bestellungen keinen passenden Kunden haben (customer_name.isna().sum()) — dies ist ein untersuchenswertes Signal für die Datenqualität. Überprüfen Sie die Form des resultierenden DataFrames, um sicherzustellen, dass durch die Zusammenführung keine unerwarteten Zeilen dupliziert oder entfernt wurden. Dokumentieren Sie die Logik der Zusammenführung in einem Kommentar für zukünftige Wartungen.
import pandas as pd
# Left join: keep all orders, enrich with customer data where available
df = pd.merge(
df_orders,
df_customers,
on='customer_id',
how='left'
)
print(f'Orders: {len(df_orders)}, Customers: {len(df_customers)}')
print(f'Merged: {df.shape}')
unmatched = df['customer_name'].isna().sum()
print(f'Orders with no matching customer: {unmatched} ({unmatched/len(df):.1%})')Vollständige Checkliste für das Daten-Audit
Führen Sie nach dem Laden und Zusammenführen vor jeder Analyse ein systematisches Daten-Audit durch. Prüfen Sie: die Gesamtzahl der Zeilen und Spalten, fehlende Werte pro Spalte (in Prozent), die Datentypen aller Spalten, doppelte Bestell-IDs, die Abdeckung des Datumsbereichs, negative Werte in numerischen Spalten sowie die Kardinalität kategorialer Spalten. Dokumentieren Sie die Ergebnisse in einer Textzusammenfassung. Wenn Sie Probleme mit der Datenqualität hier erkennen, vermeiden Sie unbemerkte Fehler bei nachgelagerten KPI-Berechnungen.
import pandas as pd
def audit_dataframe(df, name='DataFrame'):
print(f'=== Audit: {name} ===')
print(f'Shape: {df.shape}')
print(f'Date range: {df["order_date"].min()} to {df["order_date"].max()}')
print(f'Duplicate order_ids: {df["order_id"].duplicated().sum()}')
print('Missing values:')
missing = df.isnull().sum()
print(missing[missing > 0].to_string())
print('Negative quantities:', (df['quantity'] < 0).sum())
print('Negative prices:', (df['unit_price'] < 0).sum())
print()
audit_dataframe(df, 'Merged Orders + Customers')Anomalien beim Parsen von Datumsangaben beheben
Datumsspalten aus CSV-Exporten weisen häufig Sonderfälle auf: zukünftige Daten, die nicht existieren dürften, Daten aus dem falschen Jahr (ein häufiger Eingabefehler) oder fehlende Daten bei stornierten Bestellungen. Validieren Sie nach dem Parsen der Datumsangaben den erwarteten Bereich und ersetzen Sie Werte außerhalb dieses Bereichs durch NaT. Prüfen Sie außerdem, ob es Bestellungen gibt, bei denen order_date < customer signup_date gilt — unmögliche Ereignisse, die auf Probleme mit der Datenqualität hinweisen und im Auditbericht gekennzeichnet werden sollten.
import pandas as pd
from datetime import datetime
# Flag impossible dates
df['date_valid'] = (
(df['order_date'] >= '2024-01-01') &
(df['order_date'] <= datetime.now())
)
print('Invalid order dates:', (~df['date_valid']).sum())
# Flag orders before customer signup
df['signup_date'] = pd.to_datetime(df['signup_date'])
df['date_before_signup'] = df['order_date'] < df['signup_date']
print('Orders before customer signup:', df['date_before_signup'].sum())
# Set invalid dates to NaT
df.loc[~df['date_valid'], 'order_date'] = pd.NaTNegative Mengen und Retouren behandeln
Negative Mengen in einer Bestellungstabelle stehen typischerweise für Retouren oder Rückerstattungen. Entfernen Sie diese nicht einfach, sondern teilen Sie sie in zwei DataFrames auf: positive Bestellungen und Retouren. So können Sie den Bruttoumsatz (nur positive Bestellungen) und den Nettoumsatz (positive + negative Werte) getrennt berechnen und erhalten ein genaueres Bild des Geschäfts. Kennzeichnen Sie jede Zeile mit einer booleschen Spalte is_return und behalten Sie beide Arten im zusammengeführten DataFrame zu Audit-Zwecken.
import pandas as pd
# Tag returns
df['is_return'] = df['quantity'] < 0
returns = df[df['is_return']]
orders = df[~df['is_return']]
print(f'Normal orders: {len(orders)}')
print(f'Returns/refunds: {len(returns)} ({len(returns)/len(df):.1%})')
print(f'Return rate by category:')
print(
df.groupby('category')['is_return']
.mean()
.sort_values(ascending=False)
.round(3)
)Vollständigkeit der Verknüpfung prüfen
Überprüfen Sie nach einem Left Join, ob die Verknüpfung wie erwartet vollständig war. Zählen Sie, wie viele eindeutige customer_id-Werte in den Bestellungen, aber nicht in der Kundentabelle vorkommen. Dies sind verwaiste Datensätze — Kunden, die Bestellungen aufgegeben haben, für die jedoch kein Kundendatensatz vorhanden ist. Dabei kann es sich um gelöschte Konten, Gastbestellungen oder eine Lücke in der Datenpipeline handeln. Dokumentieren Sie die Anzahl und entscheiden Sie, ob Sie diese Datensätze aus der Kundenbindungsanalyse ausschließen, sie aber in die Umsatzsummen aufnehmen.
import pandas as pd
order_customers = set(df_orders['customer_id'].unique())
customer_ids = set(df_customers['customer_id'].unique())
orphans = order_customers - customer_ids
print(f'Customer IDs in orders not in customer table: {len(orphans)}')
print(f'Coverage: {len(order_customers & customer_ids) / len(order_customers):.1%} of order customers have records')
# Revenue from unmatched customers
orphan_revenue = df[df['customer_id'].isin(orphans)]['unit_price'].sum()
print(f'Revenue from orphan customers: ${orphan_revenue:,.0f}')Geprüften Datensatz speichern
Speichern Sie den bereinigten und zusammengeführten Datensatz nach dem Audit als Parquet, damit nachfolgende Pipelineschritte (Feature Engineering, KPI-Berechnung, Visualisierung) ihn sofort erneut laden können, ohne die Zusammenführung und das Parsen zu wiederholen. Schreiben Sie separate Dateien für die bereinigten Bestellungen und den DataFrame mit den Retouren. Dieses Checkpoint-Muster macht die Pipeline fortsetzbar und ermöglicht das Debuggen späterer Schritte, ohne die Datenerfassung erneut auszuführen.
import os
import pandas as pd
OS_DIR = 'output/'
os.makedirs(OS_DIR, exist_ok=True)
# Save clean orders (excluding returns and invalid dates)
clean_orders = df[
(~df['is_return']) &
df['order_date'].notna()
].copy()
clean_orders.to_parquet(OS_DIR + 'clean_orders.parquet', index=False)
df[df['is_return']].to_parquet(OS_DIR + 'returns.parquet', index=False)
print(f'Clean orders saved: {len(clean_orders):,} rows')
print(f'Returns saved: {len(df[df["is_return"]]):,} rows')
print(f'Files in {OS_DIR}: {os.listdir(OS_DIR)}')Zusammenfassungsbericht des Audits
Der letzte Schritt der Datenaufnahme besteht darin, eine kurze Prüfzusammenfassung zu erstellen, in der Ihre Ergebnisse festgehalten werden. Dies kann ein ausgedrucktes Protokoll oder eine Markdown-Datei sein. Nehmen Sie Folgendes auf: die Anzahl der aus jeder Quelle geladenen Zeilen, die Trefferquote beim Zusammenführen, den Datumsbereich, den Prozentsatz fehlender Werte, die Anzahl der gefundenen Rücksendungen sowie alle Auffälligkeiten. Die Prüfzusammenfassung wird Teil des finalen Ergebnisses und hilft Stakeholdern, darauf zu vertrauen, dass die Daten vor der Analyse ordnungsgemäß bereinigt wurden.
import pandas as pd
from datetime import datetime
def write_audit_summary(df, path):
lines = [
'# Data Ingestion Audit',
f'Generated: {datetime.now().strftime("%Y-%m-%d %H:%M")}',
'',
f'- Total records after merge: {len(df):,}',
f'- Clean orders: {(~df["is_return"]).sum():,}',
f'- Returns: {df["is_return"].sum():,}',
f'- Date range: {df["order_date"].min().date()} to {df["order_date"].max().date()}',
f'- Unique customers: {df["customer_id"].nunique():,}',
f'- Unique categories: {df["category"].nunique()}',
f'- Missing unit_price: {df["unit_price"].isna().sum()}'
]
with open(path, 'w') as f:
f.write('\n'.join(lines))
write_audit_summary(df, 'output/audit.md')
print('Audit summary written.')Kurze Überprüfung
Testen Sie Ihr Verständnis der Konzepte zur Datenanalyse aus dieser Lektion.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Die Ziele und die Konfiguration von Anfang an zu definieren hält die Pipeline fokussiert und wartbar, explizite dtype- und parse_dates-Argumente in read_csv verhindern unbemerkte Typfehler, und eine systematische Checkliste für die Datenprüfung (Duplikate, fehlende Werte, unmögliche Datumsangaben, negative Mengen) erkennt Qualitätsprobleme, bevor diese KPI-Berechnungen verfälschen. Als Nächstes bereinigen wir die Daten und entwickeln Merkmale für die Analyse.
Lerne Python mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 30
- Lektionen
- 120
Häufig gestellte Fragen
Ist die Lektion „Projekteinrichtung und Datenimport“ kostenlos?
Ja — der vollständige Text von „Projekteinrichtung und Datenimport“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Projekteinrichtung und Datenimport“?
Definieren Sie die Projektziele, laden Sie Daten aus einer CSV-Datei und einer SQLite-Datenbank, führen Sie die Quellen zusammen und prüfen Sie den kombinierten Datensatz vollständig. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?
Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Projekteinrichtung und Datenimport“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?
Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Projekteinrichtung und Datenimport
- Datenbereinigung und Feature Engineering
- Analyse und KPI-Berechnung
- Abschließende Visualisierung und Berichtexport