Pandas-Tutorial für Python — vollständiger Einstiegsleitfaden

pandas ist die am häufigsten verwendete Python-Bibliothek für die Arbeit mit strukturierten (tabellarischen) Daten. Sie stellt zwei zentrale Datenstrukturen bereit — Series und DataFrame — sowie einen umfangreichen Satz an Werkzeugen zum Laden, Bereinigen, Transformieren, Aggregieren und Visualisieren von Daten.

Dieses Kapitel behandelt alles, was Sie brauchen, um mit pandas produktiv zu arbeiten: Installation, Datenstrukturen, Dateien einlesen, Daten auswählen und filtern, fehlende Werte behandeln, gruppieren, zusammenführen und einfaches Plotten.

pandas installieren

Pandas mit pip installieren:

pip install pandas

Wenn Sie die Plotting-Beispiele später in diesem Kapitel nachvollziehen möchten, installieren Sie auch Matplotlib:

pip install matplotlib

Nach der Installation importieren Sie pandas mit dem üblichen Alias pd:

import pandas as pd

Die zwei zentralen Datenstrukturen

Series

Eine Series ist ein eindimensionales beschriftetes Array. Jedes Element hat einen Wert und ein entsprechendes Indexlabel (standardmäßig ganze Zahlen ab 0).

import pandas as pd

scores = pd.Series([88.5, 92.0, 79.5, 95.0])
print(scores)

Ausgabe:

0    88.5
1    92.0
2    79.5
3    95.0
dtype: float64

Sie können eigene Indexlabels angeben, um die Daten selbstbeschreibend zu gestalten:

scores = pd.Series(
    [88.5, 92.0, 79.5, 95.0],
    index=['Alice', 'Bob', 'Carol', 'Dave']
)
print(scores)
print(scores['Bob'])  # 92.0

Ausgabe:

Alice    88.5
Bob      92.0
Carol    79.5
Dave     95.0
dtype: float64
92.0

Eine Series mit einem aussagekräftigen Index ähnelt einem Python-Dictionary, unterstützt jedoch vektorisierte Operationen und ist in die übrige pandas-API integriert.

DataFrame

Ein DataFrame ist eine zweidimensionale Tabelle mit beschrifteten Zeilen und Spalten — stellen Sie es sich als Tabellenkalkulation oder SQL-Tabelle vor, die in Python geladen wurde. Jede Spalte ist intern eine Series, die denselben Zeilenindex teilt.

Einen DataFrame aus einem Dictionary von Listen erstellen

python— editable, runs on the server

Ausgabe:

    name  age  score
0  Alice   25   88.5
1    Bob   30   92.0
2  Carol   28   79.5
3   Dave   35   95.0

Die Dictionary-Schlüssel werden zu Spaltennamen; die Dictionary-Werte werden zu Spalten. Der Zeilenindex ist standardmäßig 0, 1, 2, 3.

Nützliche Attribute zur Inspektion eines DataFrames direkt nach der Erstellung:

Attribut / Methode	Was zurückgegeben wird
`df.shape`	Tupel aus `(rows, columns)`
`df.dtypes`	Datentyp jeder Spalte
`df.columns`	Spaltenbeschriftungen
`df.index`	Zeilenbeschriftungen
`df.head(n)`	Erste `n` Zeilen (Standard 5)
`df.tail(n)`	Letzte `n` Zeilen (Standard 5)
`df.describe()`	Zusammenfassende Statistiken für numerische Spalten
`df.info()`	Spaltennamen, Typen und Anzahl nicht-null-Werte

Daten aus Dateien lesen

In echten Projekten erstellt man DataFrames selten von Hand. pandas kann Dutzende von Dateiformaten einlesen.

Eine CSV-Datei lesen

import pandas as pd

df = pd.read_csv('sales.csv')
print(df.head())
print(df.shape)   # e.g. (1000, 5)
print(df.dtypes)

pd.read_csv() erkennt Spaltentypen automatisch. Häufig verwendete Optionen:

sep=';' — Trennzeichen ändern (Standard ist Komma)
index_col='id' — eine Spalte als Zeilenindex verwenden
parse_dates=['date'] — eine Spalte als Datum/Uhrzeit parsen
nrows=500 — nur die ersten 500 Zeilen lesen (nützlich bei großen Dateien)

Eine Excel-Datei lesen

df = pd.read_excel('report.xlsx', sheet_name='Sheet1')

Erfordert die optionale Abhängigkeit openpyxl: pip install openpyxl.

Daten zurück in eine Datei schreiben

df.to_csv('output.csv', index=False)     # CSV without the row index column
df.to_excel('output.xlsx', index=False)  # Excel

Daten auswählen

Spalten auswählen

Eine einzelne Spalte auswählen ergibt eine Series:

ages = df['age']
print(type(ages))  # <class 'pandas.core.series.Series'>

Mehrere Spalten auswählen ergibt einen DataFrame:

subset = df[['name', 'score']]
print(subset)

Ausgabe:

    name  score
0  Alice   88.5
1    Bob   92.0
2  Carol   79.5
3   Dave   95.0

Zeilen mit `loc` und `iloc` auswählen

pandas stellt zwei Hauptmethoden zur Zeilenauswahl bereit:

loc — Auswahl nach Label (Indexwert)
iloc — Auswahl nach ganzzahliger Position (0-basiert)

import pandas as pd

data = {
    'name':  ['Alice', 'Bob', 'Carol', 'Dave'],
    'age':   [25, 30, 28, 35],
    'score': [88.5, 92.0, 79.5, 95.0],
}
df = pd.DataFrame(data)

print(df.loc[1])          # row with index label 1
print()
print(df.iloc[0])         # first row by position
print()
print(df.loc[1:2])        # rows with labels 1 and 2 (inclusive)
print()
print(df.iloc[0:2])       # rows at positions 0 and 1 (end is exclusive)

Ausgabe:

name      Bob
age        30
score    92.0
Name: 1, dtype: object

name     Alice
age         25
score     88.5
Name: 0, dtype: object

   name  age  score
1   Bob   30   92.0
2  Carol   28   79.5

    name  age  score
0  Alice   25   88.5
1    Bob   30   92.0

Beachten Sie den Unterschied: loc[1:2] ist labelbasiert und auf beiden Seiten einschließend; iloc[0:2] ist positionsbasiert und rechts ausschließend (wie reguläre Python-Slices).

Sie können auch eine einzelne Zelle auswählen:

print(df.loc[1, 'score'])   # 92.0  — by label
print(df.iloc[0, 2])        # 88.5  — by position

Zeilen filtern

Zeilen mithilfe einer booleschen Bedingung in eckigen Klammern filtern:

import pandas as pd

data = {
    'name':  ['Alice', 'Bob', 'Carol', 'Dave'],
    'age':   [25, 30, 28, 35],
    'score': [88.5, 92.0, 79.5, 95.0],
}
df = pd.DataFrame(data)

# Rows where age is greater than 28
print(df[df['age'] > 28])

Ausgabe:

   name  age  score
1   Bob   30   92.0
3  Dave   35   95.0

Mehrere Bedingungen mit & (und) oder | (oder) kombinieren. Jede Bedingung immer in Klammern setzen:

# Age > 25 AND score >= 90
print(df[(df['age'] > 25) & (df['score'] >= 90)])

Ausgabe:

   name  age  score
1   Bob   30   92.0
3  Dave   35   95.0

Mit isin() nach einer Liste von Werten filtern:

print(df[df['name'].isin(['Alice', 'Carol'])])

Spalten hinzufügen und ändern

Eine neue Spalte durch Zuweisung hinzufügen:

import pandas as pd

data = {
    'name':  ['Alice', 'Bob', 'Carol', 'Dave'],
    'age':   [25, 30, 28, 35],
    'score': [88.5, 92.0, 79.5, 95.0],
}
df = pd.DataFrame(data)

# Add a column with a calculated value
df['grade'] = df['score'].apply(lambda x: 'A' if x >= 90 else 'B')
print(df)

Ausgabe:

    name  age  score grade
0  Alice   25   88.5     B
1    Bob   30   92.0     A
2  Carol   28   79.5     B
3   Dave   35   95.0     A

apply() führt eine Funktion auf jedem Element einer Spalte aus. Für einfache Berechnungen können Sie vektorisierte Operationen direkt verwenden — sie sind schneller als apply():

df['score_scaled'] = df['score'] / 100   # no apply() needed

Spalten mit rename() umbenennen:

df = df.rename(columns={'score': 'exam_score', 'age': 'years_old'})

Eine Spalte mit drop() entfernen:

df = df.drop(columns=['grade'])

Daten sortieren

Einen DataFrame nach einer oder mehreren Spalten mit sort_values() sortieren:

import pandas as pd

data = {
    'department': ['Eng', 'Eng', 'HR', 'HR', 'Eng'],
    'name':       ['Alice', 'Bob', 'Carol', 'Dave', 'Eve'],
    'salary':     [90000, 95000, 70000, 72000, 88000],
}
df = pd.DataFrame(data)

print(df.sort_values('salary', ascending=False))

Ausgabe:

  department   name  salary
1        Eng    Bob   95000
0        Eng  Alice   90000
4        Eng    Eve   88000
3         HR   Dave   72000
2         HR  Carol   70000

Nach mehreren Spalten sortieren — zum Beispiel Abteilung aufsteigend, dann Gehalt innerhalb jeder Abteilung absteigend:

df_sorted = df.sort_values(['department', 'salary'], ascending=[True, False])
print(df_sorted)

Fehlende Werte behandeln

Reale Datensätze enthalten fast immer fehlende Werte. pandas stellt diese als NaN (Not a Number) dar.

import pandas as pd

data = {
    'name':  ['Alice', 'Bob', 'Carol', 'Dave'],
    'age':   [25, None, 28, 35],
    'score': [88.5, 92.0, None, 95.0],
}
df = pd.DataFrame(data)

# Count missing values per column
print(df.isnull().sum())

Ausgabe:

name     0
age      1
score    1
dtype: int64

Fehlende Werte auffüllen

NaN durch einen festen Wert oder eine Statistik ersetzen:

df_filled = df.fillna({
    'age':   df['age'].mean(),    # fill with column mean
    'score': df['score'].median() # fill with column median
})
print(df_filled)

Ausgabe:

    name        age  score
0  Alice  25.000000   88.5
1    Bob  29.333333   92.0
2  Carol  28.000000   92.0
3   Dave  35.000000   95.0

Zeilen mit fehlenden Werten entfernen

df_dropped = df.dropna()
print(df_dropped)

Ausgabe:

    name   age  score
0  Alice  25.0   88.5
3   Dave  35.0   95.0

Wann auffüllen, wann entfernen: Das Entfernen von Zeilen bedeutet Datenverlust und kann zu Verzerrungen führen, wenn Werte nicht zufällig fehlen. Das Auffüllen (Imputation) ist meist vorzuziehen, wenn fehlende Daten selten sind. Für Machine-Learning-Workflows lesen Sie das Kapitel Scale zur Normalisierung numerischer Merkmale nach der Imputation.

Daten gruppieren

groupby() teilt den DataFrame in Gruppen auf, wendet eine Funktion auf jede Gruppe an und kombiniert die Ergebnisse. Dies ist das pandas-Äquivalent zu GROUP BY in SQL.

import pandas as pd

data = {
    'department': ['Eng', 'Eng', 'HR', 'HR', 'Eng'],
    'name':       ['Alice', 'Bob', 'Carol', 'Dave', 'Eve'],
    'salary':     [90000, 95000, 70000, 72000, 88000],
}
df = pd.DataFrame(data)

print(df.groupby('department')['salary'].mean())

Ausgabe:

department
Eng    91000.0
HR     71000.0
Name: salary, dtype: float64

Mehrere Aggregationsfunktionen gleichzeitig mit agg() anwenden:

print(df.groupby('department')['salary'].agg(['mean', 'min', 'max', 'count']))

Ausgabe:

               mean    min    max  count
department
Eng        91000.0  88000  95000      3
HR         71000.0  70000  72000      2

DataFrames zusammenführen und verketten

Zusammenführen (wie SQL JOIN)

Mit pd.merge() zwei DataFrames über eine gemeinsame Schlüsselspalte kombinieren:

import pandas as pd

employees = pd.DataFrame({
    'emp_id':  [1, 2, 3],
    'name':    ['Alice', 'Bob', 'Carol'],
    'dept_id': [10, 20, 10],
})
departments = pd.DataFrame({
    'dept_id':   [10, 20],
    'dept_name': ['Engineering', 'HR'],
})

merged = pd.merge(employees, departments, on='dept_id')
print(merged)

Ausgabe:

   emp_id   name  dept_id    dept_name
0       1  Alice       10  Engineering
1       2    Bob       20           HR
2       3  Carol       10  Engineering

Standardmäßig wird ein Inner Join verwendet (nur Zeilen mit übereinstimmendem Schlüssel in beiden DataFrames). Der Join-Typ wird mit how gesteuert:

how='left' — alle Zeilen aus dem linken DataFrame, übereinstimmende Zeilen aus dem rechten
how='right' — alle Zeilen aus dem rechten DataFrame, übereinstimmende Zeilen aus dem linken
how='outer' — alle Zeilen aus beiden DataFrames; NaN wo keine Übereinstimmung vorliegt

Verketten (DataFrames stapeln)

Mit pd.concat() DataFrames mit denselben Spalten vertikal stapeln:

import pandas as pd

q1 = pd.DataFrame({'name': ['Alice', 'Bob'],   'sales': [120, 95]})
q2 = pd.DataFrame({'name': ['Carol', 'Dave'],  'sales': [110, 130]})

combined = pd.concat([q1, q2], ignore_index=True)
print(combined)

Ausgabe:

    name  sales
0  Alice    120
1    Bob     95
2  Carol    110
3   Dave    130

ignore_index=True setzt den Zeilenindex zurück, sodass er von 0 bis 3 läuft, anstatt 0 und 1 aus jedem Quell-DataFrame zu wiederholen.

Deskriptive Statistiken

pandas macht es einfach, zusammenfassende Statistiken für einen gesamten DataFrame oder einzelne Spalten zu berechnen:

import pandas as pd

data = {
    'name':  ['Alice', 'Bob', 'Carol', 'Dave'],
    'age':   [25, 30, 28, 35],
    'score': [88.5, 92.0, 79.5, 95.0],
}
df = pd.DataFrame(data)

print(df[['age', 'score']].describe())

Ausgabe:

             age      score
count   4.000000   4.000000
mean   29.500000  88.750000
std     4.203173   6.714412
min    25.000000  79.500000
25%    27.250000  86.250000
50%    29.000000  90.250000
75%    31.250000  92.750000
max    35.000000  95.000000

Einzelne Statistiken sind auch als direkte Methoden verfügbar: df['score'].mean(), df['score'].std(), df['score'].median(), df['age'].max().

Grundlegende Datenvisualisierung

pandas ist mit Matplotlib integriert, sodass Sie direkt aus einem DataFrame mit der Methode .plot() plotten können. Installieren Sie Matplotlib zuerst, falls noch nicht geschehen: pip install matplotlib.

Liniendiagramm

import pandas as pd
import matplotlib.pyplot as plt

data = {
    'month':   ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
    'revenue': [15000, 18000, 16500, 21000, 23000],
}
df = pd.DataFrame(data)

df.plot(kind='line', x='month', y='revenue', marker='o', title='Monthly Revenue')
plt.ylabel('Revenue ($)')
plt.tight_layout()
plt.show()

Balkendiagramm

df.plot(kind='bar', x='month', y='revenue', color='steelblue', title='Monthly Revenue')
plt.ylabel('Revenue ($)')
plt.xticks(rotation=0)
plt.tight_layout()
plt.show()

Häufige Werte für den Parameter kind:

`kind`	Diagrammtyp
`'line'`	Liniendiagramm
`'bar'`	Vertikales Balkendiagramm
`'barh'`	Horizontales Balkendiagramm
`'hist'`	Histogramm
`'box'`	Boxplot
`'scatter'`	Streudiagramm (erfordert `x` und `y`)
`'pie'`	Kreisdiagramm

Für fortgeschritteneres Plotten lesen Sie die Kapitel Matplotlib Introduction und Matplotlib Scatter Plot.

Häufige Fallstricke

SettingWithCopyWarning: Wenn Sie einen DataFrame filtern und dann versuchen, das Ergebnis zu ändern, kann pandas Sie warnen, dass Sie eine Kopie statt des Originals ändern. Verwenden Sie .copy(), um dies explizit zu machen:

# Safe: work on an explicit copy
young = df[df['age'] < 30].copy()
young['group'] = 'junior'

Verkettete Indizierung: df['col'][0] = value modifiziert den ursprünglichen DataFrame möglicherweise nicht zuverlässig. Verwenden Sie für Zuweisungen immer df.loc[0, 'col'] = value.

Spaltennamen mit Leerzeichen: Wenn eine Spalte "first name" heißt, müssen Sie die Klammernotation verwenden — df['first name'] — nicht die Punktnotation (df.first name ist ein Syntaxfehler).

Integer vs. float nach fillna: Das Auffüllen von NaN in einer Integer-Spalte mit einer Zahl stuft die Spalte auf float64 hoch, da NaN ein Float ist. Verwenden Sie pd.Int64Dtype() (nullable Integer), wenn Sie Integer-Semantik mit fehlenden Werten beibehalten möchten.

pandas installieren

Die zwei zentralen Datenstrukturen

Series

DataFrame

Daten aus Dateien lesen

Eine CSV-Datei lesen

Eine Excel-Datei lesen

Daten zurück in eine Datei schreiben

Daten auswählen

Spalten auswählen

Zeilen mit loc und iloc auswählen

Zeilen filtern

Spalten hinzufügen und ändern

Daten sortieren

Fehlende Werte behandeln

Fehlende Werte auffüllen

Zeilen mit fehlenden Werten entfernen

Daten gruppieren

DataFrames zusammenführen und verketten

Zusammenführen (wie SQL JOIN)

Verketten (DataFrames stapeln)

Deskriptive Statistiken

Grundlegende Datenvisualisierung

Liniendiagramm

Balkendiagramm

Häufige Fallstricke

Verwandte Kapitel

Zeilen mit `loc` und `iloc` auswählen