Claude Code & Pandas: Datenanalyse mit Python wirklich beschleunigen

Pandas ist die Standardbibliothek für Datenanalyse in Python — und gleichzeitig eine, bei der man ständig nachschlagen muss. Welcher Parameter heißt noch mal wie? Wie kombiniert man zwei DataFrames ohne doppelte Spalten? Warum verliere ich beim groupby meinen Index? Diese kleinen Reibungspunkte summieren sich zu echtem Zeitverlust. Claude Code löst nicht nur diese Syntax-Fragen — es analysiert deine Daten direkt mit, findet Qualitätsprobleme, schreibt EDA-Code und erklärt, was im DataFrame wirklich passiert.

Dieser Artikel zeigt, wie Claude Code Datenanalyse mit Python Pandas beschleunigt: von den Grundstrukturen über Daten laden und bereinigen bis zu Aggregation, Joins und KI-gestützter explorativer Analyse.

1. Pandas-Grundstrukturen: DataFrame, Series, Index

Pandas kennt drei zentrale Datenstrukturen. Ein DataFrame ist eine zweidimensionale Tabelle mit beschrifteten Spalten und Zeilen — das Herzstück jeder Datenanalyse. Eine Series ist eine einzelne Spalte (oder Zeile) mit einem zugehörigen Index. Der Index ist die Zeilenbeschriftung — standardmäßig eine Ganzzahl-Sequenz, aber auch Datumsangaben, Strings oder Multi-Level-Indizes sind möglich.

import pandas as pd

# DataFrame aus Dictionary erstellen
df = pd.DataFrame({
    "name":    ["Anna", "Ben", "Clara"],
    "umsatz":  [12400, 8700, 19300],
    "region":  ["Nord", "Süd", "Nord"]
})

# Series: eine einzelne Spalte
s = df["umsatz"]          # dtype: int64, Index: 0, 1, 2

# Index setzen
df = df.set_index("name") # name wird zum Zeilenindex

2. Daten laden: read_csv, read_excel, read_json, read_sql

Pandas unterstützt alle gängigen Datenformate mit einer einheitlichen Schnittstelle. Die vier wichtigsten Einlesefunktionen decken den größten Teil realer Datenquellen ab:

# CSV mit Trennzeichen und Encoding
df = pd.read_csv("daten.csv", sep=";", encoding="utf-8-sig",
                 parse_dates=["datum"], dayfirst=True)

# Excel: bestimmtes Sheet, bestimmte Spalten
df = pd.read_excel("bericht.xlsx", sheet_name="Q3",
                   usecols=["Datum", "Umsatz", "Region"])

# JSON: normalisierte Nested-Struktur
df = pd.json_normalize(data["records"], sep="_")

# SQL direkt per SQLAlchemy-Engine
from sqlalchemy import create_engine
engine = create_engine("postgresql://user:pw@host/db")
df = pd.read_sql("SELECT * FROM bestellungen WHERE status = 'offen'",
                 con=engine)

Der häufigste Stolperstein beim CSV-Import: gemischte Encodings, falsches Trennzeichen oder Datumsformate die Pandas nicht automatisch erkennt. Wenn du Claude Code die ersten Zeilen deiner Datei und die Fehlermeldung übergibst, bekommst du sofort den korrekten read_csv-Aufruf mit allen nötigen Parametern — kein manuelles Ausprobieren.

3. Daten erkunden: head, info, describe, dtypes

Bevor man Daten bereinigt oder analysiert, muss man verstehen, was man hat. Die Explorative Datenanalyse (EDA) beginnt mit vier Grundbefehlen:

# Erste Zeilen ansehen
df.head(10)

# Spalten, Datentypen, Non-Null-Zählung
df.info()

# Statistische Kennzahlen für numerische Spalten
df.describe()

# Datentypen je Spalte
df.dtypes

# Fehlende Werte pro Spalte
df.isnull().sum()

# Eindeutige Werte einer kategorialen Spalte
df["region"].value_counts()

4. Daten bereinigen: dropna, fillna, astype, str-Accessor

Rohdaten sind selten sauber. Fehlende Werte, falsche Datentypen, inkonsistente Strings — die Bereinigung kostet in der Praxis oft mehr Zeit als die eigentliche Analyse. Pandas bietet dafür ein vollständiges Werkzeugset:

# Zeilen mit fehlenden Werten entfernen
df_clean = df.dropna(subset=["umsatz", "datum"])

# Fehlende Werte mit Median befüllen
df["umsatz"] = df["umsatz"].fillna(df["umsatz"].median())

# Datentyp korrigieren
df["datum"]   = pd.to_datetime(df["datum"], dayfirst=True)
df["betrag"]  = df["betrag"].astype(float)

# String-Accessor: bereinigen, normalisieren, extrahieren
df["name"] = df["name"].str.strip().str.title()
df["plz"]  = df["adresse"].str.extract(r'(\d{5})')
df["kat"]  = df["kategorie"].str.lower().str.replace(" ", "_")

5. Gruppieren und Aggregieren: groupby, pivot_table, crosstab

Die eigentliche Analyse beginnt dort, wo Daten zusammengefasst werden. Pandas bietet drei leistungsstarke Methoden:

# groupby: Umsatz pro Region und Monat
df["monat"] = df["datum"].dt.to_period("M")
agg = df.groupby(["region", "monat"])["umsatz"].agg(
    summe="sum", durchschnitt="mean", anzahl="count"
).reset_index()

# pivot_table: Kreuztabelle Umsatz je Region und Kategorie
pivot = pd.pivot_table(
    df, values="umsatz",
    index="region", columns="kategorie",
    aggfunc="sum", fill_value=0
)

# crosstab: absolute Häufigkeiten
ct = pd.crosstab(df["region"], df["kategorie"],
                 margins=True, margins_name="Gesamt")

Claude Code ist besonders hilfreich, wenn die Aggregation komplexer wird — etwa mehrere Spalten mit unterschiedlichen Funktionen, bedingte Aggregation oder Fensterfunktionen mit transform. Beschreibe das gewünschte Ergebnis in Worten, und Claude Code schreibt den richtigen groupby-Aufruf.

6. Merge und Join: merge, concat, join

Mehrere Datenquellen zusammenzuführen ist eine der häufigsten Aufgaben in der Datenanalyse. Pandas unterscheidet drei Operationen:

# merge: wie SQL JOIN, auf Schlüsselspalten
df_joined = pd.merge(
    bestellungen, kunden,
    on="kunden_id",
    how="left"          # left, right, inner, outer
)

# concat: DataFrames untereinander oder nebeneinander stapeln
df_all = pd.concat([df_q1, df_q2, df_q3], ignore_index=True)
df_wide = pd.concat([df_basis, df_extra], axis=1)

# join: Index-basierte Verknüpfung
df_result = df_left.join(df_right, how="inner", lsuffix="_l")

"Nach dem merge habe ich plötzlich doppelte Spalten 'datum_x' und 'datum_y' — wie bekomme ich das weg?" — eine typische Frage, die Claude Code in Sekunden beantwortet: suffixes=("", "_right") kombiniert mit drop(columns=["datum_right"]).

7. Claude Code Tipps für die Python-Datenanalyse

Claude Code ist kein Syntax-Nachschlagewerkzeug — es kann direkt mit deinen Daten arbeiten. Hier sind die wirkungsvollsten Einsatzmöglichkeiten:

Datenprobleme analysieren lassen

Statt selbst herauszufinden, warum ein Merge unerwartet viele Zeilen produziert oder warum ein groupby falsche Ergebnisse liefert: Claude Code den DataFrame und den Code zeigen. Es liest beide, findet das Problem und erklärt die Ursache — nicht als Vermutung, sondern als konkrete Diagnose mit Zeilenangabe.

claude "Dieser Code liefert 8.500 Zeilen, ich erwarte aber nur 1.200.
Warum?

import pandas as pd
df = pd.merge(bestellungen, artikel, on='artikel_id', how='left')
print(df.shape)"

EDA-Code automatisch generieren

Eine vollständige explorative Datenanalyse von Hand zu schreiben dauert Zeit. Claude Code kann aus einer Beschreibung deiner Daten einen vollständigen EDA-Report generieren — inklusive Verteilungsplots mit Matplotlib, Korrelationsmatrix, Ausreißer-Analyse und einer Zusammenfassung der Datenqualität. Alles als ausführbares Python-Skript.

Komplexe Transformationen in einem Schritt

Manche Transformationen sind konzeptionell klar, aber syntaktisch mühsam: gleitende Durchschnitte über Gruppen hinweg berechnen, bedingte Spalten mit mehreren Bedingungen anlegen, Zeitreihen resamplen oder Wide-Format in Long-Format umwandeln. Beschreibe das Ziel in einem Satz — Claude Code schreibt den Code, der es umsetzt.

• Fehler analysieren: Stack Trace + relevanter Code → sofortige Root-Cause-Analyse
• EDA beschleunigen: DataFrame-Struktur beschreiben → vollständiger Analyse-Code
• Transformationen: Gewünschtes Ergebnis beschreiben → Pandas-Code in einem Schritt
• Performance: Langsamer Code übergeben → vektorisierte Alternative mit Begründung

Das entscheidende Prinzip: Claude Code sieht deinen gesamten Code und deine Datenstruktur gleichzeitig. Es rät nicht, was das Problem sein könnte — es liest die relevanten Dateien und gibt eine konkrete Antwort. Das ist der Unterschied zwischen einem Syntax-Lookup und echter Analyse-Unterstützung.