Pandas — DataFrames in der Praxis

Pandas verwandelt eine CSV-Datei in einen DataFrame — eine zweidimensionale Tabelle mit benannten Spalten und einem Index. Im Unterschied zu einer Liste von Dicts kannst du mit einer einzigen Zeile filtern, gruppieren, aggregieren und sortieren. Wer das beherrscht, schreibt zehnzeiligen for-Schleifen-Code in einer Zeile um.

Diese Lektion zeigt dir die vier Operationen, die Quiz 08 abprüft — boolesche Maske, loc vs. iloc, Datentyp-Reasoning auf einer Spalte und eine kleine Datenpipeline. Wenn du das Übungsquiz am Ende bestehst, sitzen die Ideen.

Im HSG-Notebook beginnt jede Pandas-Aufgabe mit einer Zeile wie dieser:

import pandas as pd

DF = pd.read_csv('movies.csv')

pd.read_csv liest die Datei und gibt dir einen DataFrame zurück. Konvention: DF (groß geschrieben) ist der unveränderte Original-DataFrame — den fässt du nie wieder an. Alle Analysen arbeiten auf einer Kopie.

Bevor du rechnest, schau dir die Daten an. Diese vier Befehle solltest du reflexartig kennen:

DF.head(5)        # die ersten 5 Zeilen — erste Orientierung
DF.sample(5)      # 5 zufällige Zeilen — erkennt man Muster? Ausreisser?
DF.shape          # (n_zeilen, n_spalten)
DF.columns        # Liste der Spaltennamen — welche gibt es überhaupt?
DF.dtypes         # welcher Datentyp pro Spalte?

Wer das zuerst aufruft, spart sich Rätselraten darüber, welche Spalten existieren und wie sie heißen.

Ein DataFrame hat drei Bausteine, die du dir farblich merken kannst — die gleichen Farben tauchen in der Abbildung und im Code unten wieder auf:

• Index — die Zeilenlabels ganz links. Jede Zeile hat einen Label, den du mit loc ansprichst.
• Spaltennamen — die Kopfzeile oben. Jede Spalte hat einen Namen; du holst sie mit df['name'].
• Werte-Block — die eigentlichen Daten in der Mitte. Ein 2D-Raster, das du aggregieren, filtern und transformieren kannst.

Eine einzelne Spalte ist eine Series: ein 1D-Array, das denselben Index wie der DataFrame behält.

import pandas as pd

df = pd.DataFrame(
    {"land": ["CH", "DE", "AT"],
     "einwohner": [8.7, 84.0, 9.0]},
    index=["alpha", "beta", "gamma"],
)

df.index       # Index(['alpha', 'beta', 'gamma'])
df.columns     # Index(['land', 'einwohner'])
df.values      # 2D-Array mit dem Werte-Block
df.shape        # (3, 2) — Zeilen × Spalten

Der Index muss nicht 0, 1, 2, … sein — er kann Strings, Datumsangaben oder beliebige Hashables enthalten. Genau da entsteht der Unterschied zwischen loc und iloc in der nächsten Sektion.

Das wichtigste Begriffspaar in Pandas:

• df.loc[label] — Zugriff per Label (das, was im Index steht).
• df.iloc[i] — Zugriff per integer Position (wie ein normaler Listen-Index).

df.loc["beta"]              # Zeile mit Label 'beta'
df.iloc[1]                  # zweite Zeile (Position 1)

df.loc["beta", "einwohner"] # 84.0
df.iloc[1, 1]               # 84.0

df.loc["beta":"gamma"]      # inklusive Endlabel — 'gamma' ist dabei!
df.iloc[1:3]                # exklusive End-Position — wie Python-Slices

Der Klassiker im Quiz: df.loc[25]. Das ist kein Aufruf an Position 25, sondern an die Zeile mit Label 25 — falls du den Index nicht selbst gesetzt hast und Pandas standardmäßig 0,1,2,… vergibt, sind Label und Position zufällig identisch. Sobald du set_index(...) benutzt oder eine Spalte als Index lädst, fallen sie auseinander.

Eine boolesche Series kannst du als Maske zum Indizieren benutzen. Pandas behält nur die Zeilen, in denen die Maske True ist:

mask = df["einwohner"] > 10        # Series[bool] mit demselben Index
big = df[mask]                     # nur DE
small = df[~mask]                  # alle anderen

Mehrere Bedingungen kombinierst du mit & (UND) und | (ODER) — immer in Klammern, weil & enger bindet als >:

df[(df["einwohner"] > 5) & (df["land"] != "DE")]

Die Kombination Maske + Aggregation ist die wichtigste Pandas-Idiomatik überhaupt:

df["einwohner"][df["einwohner"] > 10].mean()   # Mittelwert nur über große Länder

Sehr häufig willst du einen einzelnen Wert aus einer Spalte:

x = df['einwohner'].iloc[1]   # 84.0 — ein Skalar

Wichtig: df['einwohner'] ist eine Series. .iloc[1] auf einer Series liefert immer einen Skalar (kein DataFrame, keine weitere Series). Welcher konkrete Datentyp das ist, hängt vom Inhalt der Spalte ab:

Spalteninhalt	Typ von x
nur ganze Zahlen	numpy.int64 (oder pd.Int64)
ganze Zahlen + NaN	float64 (NaN zwingt Pandas auf float)
Strings	str
gemischt mit object	was halt drin steht — int, str, None, …

Und: wenn i ≥ len(df), wirft iloc einen IndexError.

groupby('spalte') zerlegt den DataFrame in Gruppen. Aggregationen wie mean, sum, count rechnen pro Gruppe und liefern eine Series (bei einer Spalte) oder einen DataFrame (bei mehreren):

filme = pd.DataFrame({
    'regie': ['Nolan', 'Nolan', 'Anderson', 'Anderson', 'Anderson'],
    'dauer': [148, 169, 99, 102, None],
})
filme.groupby('regie')['dauer'].mean()
# regie
# Anderson    100.5     # NaN ignoriert, (99+102)/2
# Nolan       158.5
# Name: dauer, dtype: float64

Das Standardverhalten von groupby ist: nur Schlüssel mit mindestens einem nicht-NaN Wert in der aggregierten Spalte erscheinen. Wenn du alle Schlüssel willst, gibt es Optionen wie dropna=False.

Pandas-Pipelines bauen sich Schritt für Schritt auf. Lies sie wie eine Zutatenliste, von oben nach unten:

def average_movie_lengths():
    df = DF.copy()                                    # 1. Original nicht verändern
    df = df[['director_name', 'duration']]            # 2. nur was du brauchst
    df = df.dropna(axis='index')                      # 3. Zeilen mit NaN raus
    df = df.set_index('director_name')                # 4. Schlüssel an den Index
    df = df.groupby('director_name').mean()           # 5. pro Regie aggregieren
    return df['duration'].sort_index()                # 6. nach Index sortieren

Fünf Best Practices:

1. Immer kopieren, wenn du den Eingabe-DataFrame veränderst (copy()), sonst mutierst du den Aufrufer.
2. Spalten zuerst reduzieren — kleinere Tabellen sind einfacher zu lesen und schneller.
3. NaN explizit behandeln — dropna, fillna, oder bewusst stehen lassen.
4. Index sinnvoll setzen — viele Operationen werden danach trivial.
5. Sortieren am Ende — sonst bringt jede weitere Operation die Reihenfolge wieder durcheinander.