pandas DataFrame: Einstieg und praktische Beispiele

Sprungmarken

• Was ist pandas?
• Was ist ein DataFrame?
• DataFrame erstellen
• DataFrame importieren
• DataFrame untersuchen
• Spalten hinzufügen und löschen
• Operationen auf Spalten ausführen
• Best Practices, Alternativen und Checklisten

Was ist pandas?

pandas ist ein weit verbreitetes Python‑Paket für Datenanalyse und Datenaufbereitung. Es bietet die zentralen Datenstrukturen DataFrame und Series sowie viele Funktionen für Einlesen, Filtern, Aggregieren und Zeitreihenanalyse. pandas entstand in den späten 2000er Jahren und ist Open Source.

Installation (PyPI):

pip install pandas

Empfehlung: Arbeite interaktiv in Jupyter Notebooks. Notebooks dokumentieren Schritte, Ausgabe und Visualisierungen und machen Analysen reproduzierbar.

Important: pandas speichert Daten im Arbeitsspeicher (RAM). Bei sehr großen Datensätzen prüfe, ob sie in den verfügbaren Speicher passen.

Was ist ein DataFrame?

Ein DataFrame ist eine zweidimensionale, heterogene Tabelle. Er hat:

• Zeilenindex (Index)
• Spalten mit Namen
• Jede Spalte ist eine Series (eine 1D‑Datenreihe)

DataFrames sind analog zu Tabellen in Tabellenkalkulationen oder relationalen Datenbanken. Spalten können numerische Werte, Zeichenketten oder Zeitstempel enthalten.

Kurzdefinition: DataFrame = in‑memory Tabelle mit Index + Spalten.

DataFrame erstellen

Beispiel: Wir erstellen ein kleines DataFrame für eine lineare Funktion y = 2x + 5. Zuerst eine NumPy‑Achse:

import numpy as np
x = np.linspace(-10, 10)

Abhängige Variable y:

y = 2 * x + 5

pandas importieren und DataFrame bauen:

import pandas as pd

df = pd.DataFrame({'x': x, 'y': y})

Erläuterung: pd.DataFrame nimmt ein Mapping von Spaltennamen auf Listen/Arrays.

Code‑Snippets: Kurze Cheatsheet‑Beispiele

# Spalten anzeigen
print(df.columns)

# Erste 5 Zeilen
print(df.head())

# Neue Spalte berechnen
df['x2'] = df['x']  2

# Spalte löschen (inplace=False, gibt eine neue Kopie zurück)
df = df.drop('x2', axis=1)

DataFrame importieren

In der Praxis liest du Daten meist aus Dateien oder Datenbanken.

Excel:

df = pd.read_excel('/path/to/spreadsheet.xls')

CSV:

df = pd.read_csv('/path/to/data.csv')

Aus der Zwischenablage (praktisch bei kleinen Tabellen aus Tabellenkalkulationen):

df = pd.read_clipboard()

Hinweis: Beim Einlesen kontrolliere Datentypen (dtypes), fehlende Werte (NaN) und Zeichensatz (encoding).

DataFrame untersuchen

Grundlegende Methoden zum schnellen Überblick:

df.head()       # erste 5 Zeilen
df.tail()       # letzte 5 Zeilen
len(df)         # Anzahl Zeilen
df.shape        # (Zeilen, Spalten)
df.columns      # Spaltennamen

Slice‑Notation funktioniert wie bei Listen:

df[1:3]         # Zeilen 1 und 2

Anzahl Zeilen angeben:

df.head(10)

Beschreibende Statistik für numerische Spalten:

df.describe()

describe liefert: count, mean, std, min, 25%, 50% (Median), 75%, max. Diese Werte sind hilfreich für erste Plausibilitätschecks.

Beispiel mit einem öffentlichen Datensatz (Titanic):

# Beispiel: Titanic-Datensatz einlesen
# titanic = pd.read_csv('data/Titanic-Dataset.csv')
# titanic.head()

Spalte selektieren:

titanic['Name']
# ganze Spalte als Zeichenkette ausgegeben

Ganzer Inhalt einer langen Spalte (nicht empfohlen bei sehr großen Tabellen):

titanic['Name'].to_string()

Anzeigeoptionen ändern:

pd.set_option('display.max_rows', None)

Deskriptive Statistik einer einzelnen Spalte:

titanic['Age'].describe()

titanic['Age'].mean()
titanic['Age'].median()

Notes: Achte auf fehlende Werte (NaN). Funktionen wie mean() ignorieren standardmäßig NaN.

Spalten hinzufügen und löschen

Du kannst neue Spalten aus Berechnungen erstellen:

# Elementweise Operation
df['x_squared'] = df['x']  2

# Mehrere Spalten kombinieren
df['sum_xy'] = df['x'] + df['y']

Spalte löschen:

# gibt eine Kopie ohne die Spalte zurück
df2 = df.drop('x_squared', axis=1)

# oder inplace löschen
# df.drop('x_squared', axis=1, inplace=True)

Wichtig: axis=1 bedeutet Spalten; axis=0 bedeutet Zeilen.

Operationen auf Spalten

Arithmetik funktioniert elementweise und ist Vektorisiert (schnell):

df['z'] = df['x'] * df['y']

Mehrere Spalten auswählen:

titanic[['Name', 'Age']]

Filter (Boolean Selection):

# Zeilen mit Age > 30
older_than_30 = titanic[titanic['Age'] > 30]

# dieselbe Auswahl mit loc
older_than_30 = titanic.loc[titanic['Age'] > 30]

SQL‑Vergleich (konzeptionell):

SELECT * FROM titanic WHERE Age > 30

Gruppieren und Aggregation:

# Anzahl Überlebende nach Klasse
titanic.groupby('Pclass')['Survived'].sum()

# Durchschnittsalter nach Geschlecht
titanic.groupby('Sex')['Age'].mean()

Value counts (Häufigkeiten):

embarked = titanic['Embarked'].value_counts()

Spaltenwerte umbenennen (Mapping):

embarked = embarked.rename({'S': 'Southampton', 'C': 'Cherbourg', 'Q': 'Queenstown'})

Plotten (schnell mit pandas/Zweitebene Matplotlib):

import matplotlib.pyplot as plt
embarked.plot(kind='bar')
plt.show()

Note: Für anspruchsvollere Visualisierungen nutze seaborn oder plotly.

Best Practices und Lesbarkeit

• Nutze sprechende Spaltennamen (keine Leerzeichen, statt Leerzeichen Unterstrich).
• Prüfe dtypes sofort nach Einlesen: df.dtypes
• Behandlung fehlender Werte: df.isna().sum() und Strategien wie fillna(), dropna()
• Kopien vs. Views: Achte auf SettingWithCopyWarning beim Zuweisen in Slices
• Versionierung: Dokumentiere Code in Notebooks oder Skripten und benutze Versionskontrolle

Important: Vor Transformationen stets die Datentypen und fehlende Werte prüfen. Fehleinschätzungen führen zu stillschweigenden Fehlern.

Mini‑Methodologie: 7 Schritte für Explorative Datenanalyse (EDA) mit pandas

1. Daten einlesen und erste Struktur prüfen (shape, columns)
2. Fehlende Werte und Datentypen identifizieren (isna, dtypes)
3. Deskriptive Statistik (describe, value_counts)
4. Visualisierungen für Verteilungen und Zusammenhänge (hist, boxplot, scatter)
5. Feature‑Engineering: neue Spalten erstellen
6. Aggregation und Gruppierung (groupby)
7. Ergebnis speichern und reproduzierbar machen (to_csv, to_parquet)

Wann pandas ungeeignet ist (Gegenbeispiele)

• Datensätze, die nicht in den Arbeitsspeicher passen. Alternative: Dask, Vaex, PySpark.
• Hochparallele Verarbeitungsworkflows mit verteiltem Speicher: PySpark oder spezialisierte Datenbanken sind besser.
• STRONG‑SLICE‑Usecases mit strengen Latenzanforderungen in Produktumgebungen: Datenbanken/Serverlösungen bevorzugen.

Alternative Ansätze

• NumPy‑Arrays für numerisch intensive Operationen ohne Spaltennamen.
• SQLite/Postgres für persistente Abfragen und Transaktionen.
• Dask / Vaex für out‑of‑core und verteilte Berechnung.
• Polars (neues Rust‑basiertes DataFrame) für hohe Performance bei großen Tabellen.

Rolleorientierte Checkliste

Data Scientist

• Notebook mit sauberem EDA‑Workflow
• Fehlende Werte dokumentiert
• Reproduzierbare Visualisierungen

Datenanalyst

• Prüfe Spaltennamen und Datentypen
• Aggregationen und KPI‑Berechnungen

Dateningenieur

• Pipeline für Einlesen, Validierung, Speicherung
• Performance und Speicherverbrauch überwachen

Sicherheit, Datenschutz und GDPR‑Hinweise

• Persönlich identifizierbare Informationen (PII) nur nach Bedarf speichern.
• Anonymisiere oder pseudonymisiere Daten vor Freigabe.
• Beachte lokale Datenschutzvorschriften und Betriebsvereinbarungen.

Fehlerbehandlung und Tests (Akzeptanzkriterien)

• CSV/Excel wird erfolgreich eingelesen ohne Encoding‑Fehler.
• Erwartete Spalten sind vorhanden: set(expected_columns).issubset(set(df.columns))
• Anzahl fehlender Werte pro Spalte unter definiertem Schwellenwert.
• Datentypen entsprechen dem Schema (z. B. Age ist numerisch).

Kurze Code‑Cheat‑Sheet: Häufige Operationen

# Auswahl
col = df['colname']
cols = df[['col1', 'col2']]
row = df.loc[3]

# Filter
subset = df[df['col'] > 0]

# Gruppieren
agg = df.groupby('groupcol').agg({'value': ['mean', 'sum']})

# Sortieren
sorted_df = df.sort_values('col', ascending=False)

# Speichern
df.to_csv('out.csv', index=False)

Entscheidungshilfe (Mermaid)

flowchart TD
  A[Start: Datenanalysebedarf] --> B{Passt der Datensatz in RAM?}
  B -- Ja --> C[Verwende pandas]
  B -- Nein --> D{Benötigst du verteiltes Rechnen?}
  D -- Ja --> E[Verwende PySpark oder Dask]
  D -- Nein --> F[Verwende Vaex oder Polars 'out‑of‑core']
  C --> G[EDA mit pandas]

Glossar (1‑Zeile Definitionen)

• DataFrame: Zweidimensionale, beschriftete Tabelle in pandas.
• Series: Eine einzelne Spalte in einem DataFrame.
• Index: Lookup‑Struktur für Zeilen im DataFrame.
• dtype: Datentyp einer Series/Spalte (z. B. int, float, datetime).

Kurze Fallbeispiele und Tests

• Test: Nach Einlesen sind die wichtigsten Spalten vorhanden.
• Test: Keine kritischen NaNs in Schlüsselspalten.
• Test: Aggregationsergebnisse plausibel (z. B. Summen, Mittelwerte innerhalb erwarteter Bereiche).

Fazit

pandas ist ein flexibles Toolset für tabellarische Daten in Python. Es eignet sich ideal für Exploration, Transformation und Vorbereitung von Daten für Analyse und Modellierung. Bei sehr großen Datenmengen oder verteilten Workloads greife auf spezialisierte Alternativen zurück. Nutze Notebooks für Reproduzierbarkeit, prüfe Datentypen und fehlende Werte und dokumentiere jeden Transformationsschritt.

Wichtige Takeaways:

• DataFrame = zentrale Struktur für Tabellendaten in pandas.
• Checke Datentypen und fehlende Werte direkt nach dem Einlesen.
• Verwende groupby, value_counts und describe für schnelle Insights.

Dieses Dokument soll als praktischer Einstieg und als Referenz beim Arbeiten mit pandas dienen.