Seaborn Heatmap: Vollständiger Leitfaden zur Erstellung von Heatmaps in Python

Name

Soren Atelier

Updated on 9.2.2026

Sie haben einen Datensatz mit Dutzenden von Variablen. Sie müssen verstehen, welche Features korrelieren, wo sich Muster verbergen oder warum Ihr maschinelles Lernmodell ständig fehlerhaft arbeitet. Das Anstarren von Zeilen und Spalten mit Zahlen sagt Ihnen fast nichts. Genau dieses Problem löst eine seaborn Heatmap – sie wandelt eine dichte Matrix von Werten in ein farbcodiertes Raster um, das Ihr Gehirn in Sekunden verarbeiten kann.

Heatmaps gehören zu den am häufigsten verwendeten Visualisierungstypen in der Data Science, und Pythons seaborn-Bibliothek macht ihre Erstellung bemerkenswert einfach. Egal, ob Sie eine Korrelationsmatrix erstellen, eine Konfusionsmatrix analysieren oder Zeitreihenmuster visualisieren, sns.heatmap() liefert Ihnen mit nur wenigen Codezeilen ein veröffentlichungsreifes Diagramm.

Dieser Leitfaden führt Sie durch alles: grundlegende Syntax, Anpassungsoptionen, fortgeschrittene Techniken wie geclusterte Heatmaps und eine vollständige Parameterreferenztabelle. Jedes Codebeispiel ist sofort einsatzbereit.

Grundlegende Seaborn Heatmap Syntax

Die Kernfunktion ist sns.heatmap(). Sie akzeptiert einen 2D-Datensatz – typischerweise einen pandas DataFrame oder ein NumPy-Array – und rendert ihn als farbiges Raster.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
# Create sample data
data = np.random.rand(5, 7)
ax = sns.heatmap(data)
plt.title("Basic Seaborn Heatmap")
plt.show()

Das ist die einfachstmögliche Heatmap. Die Farbe jeder Zelle repräsentiert ihren numerischen Wert, und seaborn fügt automatisch eine Farbskala auf der rechten Seite hinzu. Aber die praktische Anwendung beinhaltet fast immer mehr Konfiguration, die wir als Nächstes behandeln werden.

Erstellen einer Korrelationsmatrix-Heatmap

Der häufigste Anwendungsfall für eine seaborn Heatmap ist die Visualisierung einer Korrelationsmatrix. Diese zeigt Ihnen, wie stark jedes Paar von Variablen in Ihrem Datensatz miteinander verbunden ist.

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
 
# Load a built-in dataset
df = sns.load_dataset("mpg").select_dtypes(include="number")
 
# Compute the correlation matrix
corr = df.corr()
 
# Plot the heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(
    corr,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    center=0,
    square=True,
    linewidths=0.5
)
plt.title("Correlation Matrix - MPG Dataset")
plt.tight_layout()
plt.show()

Wichtige Dinge, die hier passieren:

• annot=True druckt den Korrelationskoeffizienten in jede Zelle.
• fmt=".2f" formatiert diese Zahlen auf zwei Dezimalstellen.
• cmap="coolwarm" verwendet eine divergierende Farbpalette, wobei negative Korrelationen blau und positive Korrelationen rot sind.
• center=0 stellt sicher, dass null Korrelation der neutralen Mittelpunktfarbe zugeordnet wird.
• square=True erzwingt, dass jede Zelle ein perfektes Quadrat ist, für sauberere Visualisierungen.

Anpassungsoptionen

Farbpaletten (cmap-Parameter)

Der cmap-Parameter steuert das Farbschema. Die Wahl der richtigen Palette hängt von Ihrem Datentyp ab.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(6, 6)
fig, axes = plt.subplots(1, 3, figsize=(18, 5))
 
cmaps = ["viridis", "coolwarm", "YlOrRd"]
for ax, cmap in zip(axes, cmaps):
    sns.heatmap(data, cmap=cmap, ax=ax, annot=True, fmt=".2f")
    ax.set_title(f'cmap="{cmap}"')
 
plt.tight_layout()
plt.show()

Annotationen (annot- und fmt-Parameter)

Annotationen zeigen den numerischen Wert innerhalb jeder Zelle an. Sie können deren Format steuern:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.randint(0, 1000, size=(4, 5))
 
plt.figure(figsize=(8, 5))
sns.heatmap(
    data,
    annot=True,
    fmt="d",            # integer format
    cmap="Blues",
    annot_kws={"size": 14, "weight": "bold"}  # customize font
)
plt.title("Heatmap with Integer Annotations")
plt.show()

Häufige fmt-Werte: ".2f" für zwei Dezimalstellen, "d" für Ganzzahlen, ".1%" für Prozentsätze, ".1e" für wissenschaftliche Notation.

Abbildungsgröße und Seitenverhältnis

Seaborn Heatmaps erben ihre Größe von der matplotlib-Abbildung. Stellen Sie sie vor dem Aufruf von sns.heatmap() ein:

plt.figure(figsize=(12, 8))  # width=12, height=8 inches
sns.heatmap(data, cmap="viridis")
plt.show()

Für quadratische Zellen übergeben Sie square=True an sns.heatmap(). Dies überschreibt das Seitenverhältnis der Abbildung, um jede Zelle gleich groß zu machen.

Maskieren des oberen oder unteren Dreiecks

Korrelationsmatrizen sind symmetrisch. Das Anzeigen beider Hälften ist redundant. Verwenden Sie NumPys triu oder tril, um eine Hälfte zu maskieren:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
df = sns.load_dataset("mpg").select_dtypes(include="number")
corr = df.corr()
 
# Create a mask for the upper triangle
mask = np.triu(np.ones_like(corr, dtype=bool))
 
plt.figure(figsize=(10, 8))
sns.heatmap(
    corr,
    mask=mask,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    center=0,
    square=True,
    linewidths=0.5
)
plt.title("Lower Triangle Correlation Heatmap")
plt.tight_layout()
plt.show()

Der mask-Parameter akzeptiert ein boolesches Array mit derselben Form wie die Daten. Zellen, bei denen mask=True ist, werden ausgeblendet.

Heatmap-Parameterreferenztabelle

Fortgeschrittene Beispiele

Geclusterte Heatmap mit sns.clustermap

Wenn Sie ähnliche Zeilen und Spalten zusammengruppieren möchten, wendet sns.clustermap() hierarchisches Clustering an und ordnet die Achsen automatisch neu:

import seaborn as sns
import matplotlib.pyplot as plt
 
df = sns.load_dataset("mpg").select_dtypes(include="number").dropna()
corr = df.corr()
 
g = sns.clustermap(
    corr,
    annot=True,
    fmt=".2f",
    cmap="vlag",
    center=0,
    linewidths=0.5,
    figsize=(8, 8),
    dendrogram_ratio=0.15
)
g.ax_heatmap.set_title("Clustered Correlation Heatmap", pad=60)
plt.show()

Die Dendrogramme links und oben zeigen die Clustering-Hierarchie. Variablen, die am engsten korreliert sind, werden nebeneinander platziert, wodurch Muster viel leichter zu erkennen sind.

Benutzerdefinierte Farbbereiche (vmin, vmax)

Standardmäßig skaliert seaborn Farben auf das Minimum und Maximum Ihrer Daten. Sie können dies überschreiben, um mehrere Heatmaps auf derselben Skala zu vergleichen oder einen bestimmten Bereich hervorzuheben:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.uniform(-1, 1, size=(8, 8))
 
plt.figure(figsize=(8, 6))
sns.heatmap(
    data,
    vmin=-1,
    vmax=1,
    center=0,
    cmap="RdBu_r",
    annot=True,
    fmt=".2f"
)
plt.title("Heatmap with Fixed Color Range (-1 to 1)")
plt.show()

Das Setzen von vmin=-1 und vmax=1 ist besonders nützlich beim Plotten von Korrelationsmatrizen oder normalisierten Daten, bei denen der theoretische Bereich bekannt ist.

Konfusionsmatrix-Heatmap

Eine weitere praktische Anwendung ist die Visualisierung einer Konfusionsmatrix aus einem Klassifizierungsmodell:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import confusion_matrix
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
 
# Train a quick model
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.3, random_state=42
)
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
 
# Build and plot the confusion matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(7, 5))
sns.heatmap(
    cm,
    annot=True,
    fmt="d",
    cmap="Blues",
    xticklabels=iris.target_names,
    yticklabels=iris.target_names
)
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Confusion Matrix - Iris Classification")
plt.tight_layout()
plt.show()

Die Diagonale zeigt korrekte Vorhersagen. Nicht-diagonale Zellen zeigen, wo das Modell eine Klasse mit einer anderen verwechselt.

Zeitreihen-Heatmap

Heatmaps funktionieren auch gut zum Erkennen von Mustern über Zeitdimensionen hinweg. Hier ist ein Beispiel, das Aktivität nach Wochentag und Stunde zeigt:

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
np.random.seed(0)
hours = list(range(24))
days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
data = pd.DataFrame(
    np.random.poisson(lam=20, size=(7, 24)),
    index=days,
    columns=hours
)
 
plt.figure(figsize=(14, 5))
sns.heatmap(data, cmap="YlOrRd", linewidths=0.3, annot=False)
plt.xlabel("Hour of Day")
plt.ylabel("Day of Week")
plt.title("Activity Heatmap by Day and Hour")
plt.tight_layout()
plt.show()

Seaborn Heatmap vs Matplotlib imshow

Sie können auch mit matplotlib.pyplot.imshow() heatmap-ähnliche Visualisierungen erstellen. So vergleichen sich die beiden:

Fazit: Verwenden Sie sns.heatmap(), wenn Sie mit minimalem Code eine saubere, gut beschriftete Heatmap wünschen. Greifen Sie auf imshow() zurück, wenn Sie pixelgenaue Kontrolle benötigen oder mit Bilddaten statt tabellarischen Daten arbeiten.

Interaktive Alternative: PyGWalker

Statische Heatmaps sind leistungsstark für Berichte und Papiere, aber während der explorativen Datenanalyse möchten Sie oft mit Ihren Daten interagieren – filtern, pivotieren, aufschlüsseln und zwischen Diagrammtypen wechseln, ohne Code neu zu schreiben.

PyGWalker (opens in a new tab) (Python-Binding von Graphic Walker) verwandelt jeden pandas DataFrame direkt in Jupyter Notebook in eine Tableau-ähnliche interaktive Benutzeroberfläche. Sie können Felder per Drag-and-Drop verschieben, um Heatmaps, Streudiagramme, Balkendiagramme und mehr zu erstellen, ohne überhaupt Visualisierungscode zu schreiben.

pip install pygwalker

import pandas as pd
import pygwalker as pyg
 
df = pd.read_csv("your_data.csv")
walker = pyg.walk(df)

Sobald die interaktive Oberfläche gestartet ist, können Sie:

• Eine kategorische Variable auf Zeilen ziehen, eine andere auf Spalten und ein Maß auf Farbe, um eine Heatmap zu erstellen.
• Sofort zu anderen Diagrammtypen (Balken, Linie, Streuung) wechseln.
• Filtern und aggregieren, ohne zusätzlichen Code zu schreiben.

Dies ist besonders nützlich, wenn Sie noch erkunden, welche Variablen Sie in Ihre endgültige seaborn Heatmap einbeziehen möchten. Verwenden Sie PyGWalker für die Explorationsphase und sichern Sie dann Ihre endgültige statische Visualisierung mit sns.heatmap() zum Teilen.

Häufig gestellte Fragen

Wie ändere ich die Größe einer seaborn Heatmap?

Stellen Sie die Abbildungsgröße vor dem Aufruf von sns.heatmap() mit plt.figure(figsize=(width, height)) ein. Zum Beispiel erstellt plt.figure(figsize=(12, 8)) eine 12x8 Zoll große Abbildung. Sie können auch einen ax-Parameter übergeben, wenn Sie mit Subplots arbeiten.

Wie annotiere ich eine seaborn Heatmap mit Werten?

Übergeben Sie annot=True an sns.heatmap(). Steuern Sie das Zahlenformat mit dem fmt-Parameter (z.B. fmt=".2f" für zwei Dezimalstellen). Passen Sie Schriftarteigenschaften mit annot_kws an, zum Beispiel: annot_kws={"size": 12, "weight": "bold"}.

Was ist der Unterschied zwischen sns.heatmap und sns.clustermap?

sns.heatmap() zeigt Daten in der ursprünglichen Zeilen- und Spaltenreihenfolge an. sns.clustermap() wendet hierarchisches Clustering an, um Zeilen und Spalten neu zu ordnen, sodass ähnliche Werte gruppiert werden, und fügt Dendrogramme hinzu, um die Clustering-Struktur zu zeigen.

Wie maskiere ich die Hälfte einer Korrelations-Heatmap?

Verwenden Sie NumPy, um eine boolesche Maske zu erstellen. Für das obere Dreieck: mask = np.triu(np.ones_like(corr, dtype=bool)). Übergeben Sie dann mask=mask an sns.heatmap(). Für das untere Dreieck verwenden Sie stattdessen np.tril().

Kann ich eine seaborn Heatmap als Bilddatei speichern?

Ja. Nach dem Erstellen der Heatmap rufen Sie plt.savefig("heatmap.png", dpi=300, bbox_inches="tight") vor plt.show() auf. Seaborn Heatmaps unterstützen alle matplotlib-Ausgabeformate einschließlich PNG, SVG, PDF und EPS.

Fazit

Die seaborn Heatmap ist eines der vielseitigsten Werkzeuge im Visualisierungs-Toolkit eines Data Scientists. Von Korrelationsanalysen über Konfusionsmatrizen bis hin zur Erkennung von Zeitreihenmustern – sns.heatmap() bewältigt all dies mit sauberer Syntax und veröffentlichungsreifer Ausgabe.

Beginnen Sie mit den Grundlagen – übergeben Sie Ihre Daten und wählen Sie eine Farbkarte. Fügen Sie dann je nach Analysebedarf Annotationen, Maskierung, benutzerdefinierte Bereiche und Clustering hinzu. Für die Explorationsphase, bevor Sie eine endgültige Visualisierung festlegen, können Tools wie PyGWalker (opens in a new tab) Ihren Workflow mit interaktiven Drag-and-Drop-Diagrammen beschleunigen.

Die Codebeispiele in diesem Leitfaden sind alle sofort einsatzbereit. Wählen Sie das Beispiel aus, das Ihrem Anwendungsfall am nächsten kommt, tauschen Sie Ihre Daten aus, und Sie haben in weniger als einer Minute eine klare, informative Heatmap.