Data Wrangling: Vollständiger Leitfaden zum Bereinigen und Transformieren von Daten mit Python

import pandas as pd
 
df = pd.read_csv("sales_data.csv")
 
# Form und grundlegende Informationen
print(f"Zeilen: {df.shape[0]}, Spalten: {df.shape[1]}")
df.info()
 
# Statistische Zusammenfassung
df.describe(include="all")
 
# Fehlende Werte prüfen
df.isnull().sum().sort_values(ascending=False)
 
# Auf Duplikate prüfen
print(f"Doppelte Zeilen: {df.duplicated().sum()}")
 
# Einzigartige Werte in kategorischen Spalten anzeigen
for col in df.select_dtypes(include="object").columns:
    print(f"{col}: {df[col].nunique()} einzigartige Werte")
    print(df[col].value_counts().head(5))
    print()

# Spaltennamen standardisieren: Kleinbuchstaben, Unterstriche, keine Leerzeichen
df.columns = (
    df.columns
    .str.strip()
    .str.lower()
    .str.replace(" ", "_")
    .str.replace(r"[^\w]", "", regex=True)
)

# Pivot: Langes Format in breites Format konvertieren
sales_wide = df.pivot_table(
    index="product",
    columns="month",
    values="revenue",
    aggfunc="sum"
)
 
# Melt: Breites Format zurück in langes Format
sales_long = sales_wide.reset_index().melt(
    id_vars="product",
    var_name="month",
    value_name="revenue"
)

# Strategie 1: Zeilen mit fehlenden Werten entfernen
df_dropped = df.dropna()
 
# Strategie 2: Nur Zeilen mit fehlenden Werten in bestimmten Spalten entfernen
df_dropped = df.dropna(subset=["revenue", "customer_id"])
 
# Strategie 3: Mit einer Konstante füllen
df["category"] = df["category"].fillna("Unbekannt")
 
# Strategie 4: Mit Spaltenstatistik füllen
df["revenue"] = df["revenue"].fillna(df["revenue"].median())
 
# Strategie 5: Vorwärts füllen (gut für Zeitreihen)
df["price"] = df["price"].ffill()
 
# Strategie 6: Interpolation (gut für numerische Zeitreihen)
df["temperature"] = df["temperature"].interpolate(method="linear")

# String zu Datetime
df["order_date"] = pd.to_datetime(df["order_date"], format="%Y-%m-%d")
 
# String zu numerisch (coerce wandelt nicht parsbare Werte in NaN um)
df["revenue"] = pd.to_numeric(df["revenue"], errors="coerce")
 
# Objekt zu Kategorie (spart Speicher)
df["status"] = df["status"].astype("category")
 
# Boolean-Konvertierung
df["is_active"] = df["is_active"].map({"yes": True, "no": False, "Y": True, "N": False})

# Leerzeichen entfernen
df["name"] = df["name"].str.strip()
 
# Groß-/Kleinschreibung standardisieren
df["city"] = df["city"].str.lower()
df["state"] = df["state"].str.upper()
 
# Muster mit Regex ersetzen
df["phone"] = df["phone"].str.replace(r"[^\d]", "", regex=True)
 
# Muster extrahieren
df["zip_code"] = df["address"].str.extract(r"(\d{5})")

# Duplikate finden
print(f"Gesamte Duplikate: {df.duplicated().sum()}")
 
# Duplikate basierend auf bestimmten Spalten finden
dupes = df[df.duplicated(subset=["customer_id", "order_date"], keep=False)]
 
# Duplikate entfernen, erste Vorkommen behalten
df = df.drop_duplicates(subset=["customer_id", "order_date"], keep="first")

# Inner Join: nur übereinstimmende Zeilen
merged = pd.merge(orders, customers, on="customer_id", how="inner")
 
# Left Join: alle Bestellungen, mit Kundeninfo wo verfügbar
merged = pd.merge(orders, customers, on="customer_id", how="left")
 
# DataFrames vertikal verketten (Zeilen stapeln)
all_months = pd.concat([jan_df, feb_df, mar_df], ignore_index=True)

# Berechnete Spalten
df["profit"] = df["revenue"] - df["cost"]
df["profit_margin"] = (df["profit"] / df["revenue"] * 100).round(2)
 
# Kontinuierliche Werte kategorisieren
df["revenue_tier"] = pd.cut(
    df["revenue"],
    bins=[0, 100, 500, 1000, float("inf")],
    labels=["Niedrig", "Mittel", "Hoch", "Premium"]
)

def validate_dataframe(df):
    """Grundlegende Validierungsprüfungen auf einem bereinigten DataFrame ausführen."""
    checks = {}
    required = ["customer_id", "order_date", "revenue"]
    for col in required:
        null_count = df[col].isnull().sum()
        checks[f"no_nulls_{col}"] = null_count == 0
        if null_count > 0:
            print(f"WARNUNG: {col} hat {null_count} Null-Werte")
 
    neg_revenue = (df["revenue"] < 0).sum()
    checks["positive_revenue"] = neg_revenue == 0
 
    passed = sum(checks.values())
    total = len(checks)
    print(f"\nValidierung: {passed}/{total} Prüfungen bestanden")
    return checks
 
validate_dataframe(df)

import numpy as np
 
# Methode 1: IQR (Interquartilabstand)
Q1 = df["revenue"].quantile(0.25)
Q3 = df["revenue"].quantile(0.75)
IQR = Q3 - Q1
lower = Q1 - 1.5 * IQR
upper = Q3 + 1.5 * IQR
 
outliers = df[(df["revenue"] < lower) | (df["revenue"] > upper)]
print(f"IQR-Ausreißer: {len(outliers)} Zeilen")
 
# Behandlungsoptionen
# Option A: Ausreißer entfernen
df_clean = df[(df["revenue"] >= lower) & (df["revenue"] <= upper)]
 
# Option B: Ausreißer deckeln (Winsorisierung)
df["revenue_capped"] = df["revenue"].clip(lower=lower, upper=upper)
 
# Option C: Ausreißer zur manuellen Überprüfung markieren
df["is_outlier"] = (df["revenue"] < lower) | (df["revenue"] > upper)

import pandas as pd
import numpy as np
 
def wrangle_sales_data(filepath):
    """Vollständige Data Wrangling-Pipeline für Verkaufsdaten."""
    df = pd.read_csv(filepath)
    df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
    df["order_date"] = pd.to_datetime(df["order_date"], errors="coerce")
    df["revenue"] = pd.to_numeric(df["revenue"], errors="coerce")
    df["quantity"] = pd.to_numeric(df["quantity"], errors="coerce")
 
    for col in df.select_dtypes(include="object").columns:
        df[col] = df[col].str.strip()
 
    df = df.dropna(subset=["order_date", "customer_id"])
    df["revenue"] = df["revenue"].fillna(df["revenue"].median())
    df["category"] = df["category"].fillna("Unbekannt")
    df = df.drop_duplicates(subset=["customer_id", "order_date", "product_id"], keep="first")
    df["order_year"] = df["order_date"].dt.year
    df["order_month"] = df["order_date"].dt.month
 
    Q1 = df["revenue"].quantile(0.25)
    Q3 = df["revenue"].quantile(0.75)
    IQR = Q3 - Q1
    df = df[(df["revenue"] >= Q1 - 1.5 * IQR) & (df["revenue"] <= Q3 + 1.5 * IQR)]
    df = df.reset_index(drop=True)
    return df
 
clean_df = wrangle_sales_data("raw_sales.csv")
print(f"Bereinigter Datensatz: {clean_df.shape[0]} Zeilen, {clean_df.shape[1]} Spalten")