Matplotlib-Colormap: Vollständiger Leitfaden zu Color Maps in Python

Name

Soren Atelier

Updated on 12.2.2026

Die richtigen Farben für eine Datenvisualisierung zu wählen ist überraschend schwierig. Nimm eine Regenbogen-Colormap und dein Heatmap wirkt dramatisch – aber die wahrnehmungsbedingte Nicht-Uniformität verzerrt die Daten, führt Betrachter in die Irre und funktioniert für Menschen mit Farbsehschwäche oft gar nicht. Nutzt du hingegen eine Einfarb-Palette, verschwinden subtile Muster in einer Wand fast identischer Farbtöne. Der Unterschied zwischen einem Diagramm, das Erkenntnisse sichtbar macht, und einem, das sie versteckt, hängt oft an einer einzigen Entscheidung: der Colormap.

Matplotlib liefert über 150 integrierte Colormaps sowie eine flexible API, um eigene zu erstellen. Die Herausforderung ist nicht mangelnde Auswahl – sondern zu wissen, welche Colormap man wann verwendet und wie man sie für den jeweiligen Datensatz anpasst. Eine schlechte Wahl kann die Genauigkeit deiner Visualisierung unbemerkt ruinieren; die richtige macht komplexe Daten sofort lesbar.

Dieser Leitfaden behandelt alle praktischen Aspekte von Matplotlib-Colormaps: die vier Hauptkategorien, die wichtigsten eingebauten Maps, wie man sie über verschiedene Plot-Typen hinweg anwendet, wie man eigene Colormaps von Grund auf erstellt und wie man eine Colormap wählt, die sowohl wissenschaftlich korrekt als auch barrierearm ist.

Was ist eine Colormap in Matplotlib?

Eine Colormap ist eine Abbildungsfunktion, die skalare Datenwerte in Farben übersetzt. Aus einer Zahl (typischerweise normalisiert auf den Bereich 0–1) liefert die Colormap ein RGBA-Farbtuple zurück. Matplotlib repräsentiert Colormaps als Objekte, die von matplotlib.colors.Colormap erben, und jede Plot-Funktion, die einen cmap-Parameter akzeptiert, nutzt dieses System intern.

import matplotlib.pyplot as plt
import numpy as np
 
# A colormap is a callable: pass a float in [0, 1], get an RGBA tuple
cmap = plt.colormaps['viridis']
print(cmap(0.0))   # dark purple
print(cmap(0.5))   # teal-green
print(cmap(1.0))   # bright yellow

Wenn du plt.imshow(data, cmap='viridis') schreibst, normalisiert Matplotlib deine Daten zunächst mit einem Normalize-Objekt auf [0, 1] und führt anschließend für jeden normalisierten Wert einen Farbnachschlag in der Colormap durch, um die endgültigen Pixelfarben zu erzeugen. Dieses zweistufige Vorgehen zu verstehen – Normalisierung, dann Farbnachschlag – ist der Schlüssel, um jeden Aspekt von Farbe in deinen Plots kontrollieren zu können.

Die vier Kategorien von Colormaps

Matplotlib organisiert seine Colormaps in vier funktionale Kategorien. Jede dient einem anderen Datentyp – und die falsche Kategorie zu verwenden ist der häufigste Colormap-Fehler überhaupt.

Sequentielle Colormaps

Sequentielle Colormaps variieren gleichmäßig von hell nach dunkel (oder dunkel nach hell) in einem einzigen Farbton oder in einem engen Farbbereich. Sie sind für Daten gedacht, die eine natürliche Ordnung von niedrig nach hoch haben – ohne besonderen Mittelpunkt.

Wann verwenden: Temperaturmessungen, Bevölkerungsdichte, Höhe, Wahrscheinlichkeit, jede kontinuierliche Variable mit sinnvoller Richtung.

Wichtige Beispiele: viridis, plasma, inferno, magma, cividis, Blues, Greens, OrRd, YlGnBu

import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(12, 12)
 
fig, axes = plt.subplots(1, 3, figsize=(14, 4))
 
for ax, name in zip(axes, ['viridis', 'plasma', 'inferno']):
    im = ax.imshow(data, cmap=name)
    ax.set_title(f'Sequential: {name}')
    fig.colorbar(im, ax=ax, shrink=0.8)
 
plt.tight_layout()
plt.show()

Divergierende Colormaps

Divergierende Colormaps verwenden zwei kontrastierende Farbtöne, die sich an einem neutralen Mittelpunkt treffen (meist weiß oder hellgrau). Sie betonen Abweichungen in beide Richtungen von einem zentralen Wert.

Wann verwenden: Temperaturanomalien (über/unter Durchschnitt), Korrelationsmatrizen, Gewinn/Verlust, alle Daten, bei denen Null oder ein Mittelpunkt eine besondere Bedeutung hat.

Wichtige Beispiele: coolwarm, RdBu, RdYlGn, BrBG, PiYG, seismic, bwr

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.randn(10, 10)  # Values centered around zero
 
fig, axes = plt.subplots(1, 3, figsize=(14, 4))
 
for ax, name in zip(axes, ['coolwarm', 'RdBu', 'seismic']):
    im = ax.imshow(data, cmap=name, vmin=-3, vmax=3)
    ax.set_title(f'Diverging: {name}')
    fig.colorbar(im, ax=ax, shrink=0.8)
 
plt.tight_layout()
plt.show()

Tipp: Setze vmin und vmax immer symmetrisch um den Mittelpunkt, damit die neutrale Farbe mit Null (oder deinem gewählten Zentrum) übereinstimmt.

Qualitative Colormaps

Qualitative Colormaps liefern eine Menge visuell gut unterscheidbarer Farben ohne implizite Ordnung. Jede Farbe unterscheidet sich maximal von ihren Nachbarn – ideal für kategoriale Labels.

Wann verwenden: Cluster-Labels, kategoriale Scatter Plots, Balkendiagramme mit ungeordneten Gruppen.

Wichtige Beispiele: tab10, tab20, Set1, Set2, Set3, Paired, Accent

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(7)
categories = 6
x = np.concatenate([np.random.randn(30) + i * 3 for i in range(categories)])
y = np.concatenate([np.random.randn(30) + i * 1.5 for i in range(categories)])
labels = np.concatenate([np.full(30, i) for i in range(categories)])
 
plt.figure(figsize=(9, 6))
scatter = plt.scatter(x, y, c=labels, cmap='tab10', s=50, alpha=0.8, edgecolors='white')
plt.colorbar(scatter, label='Category')
plt.title('Qualitative Colormap: tab10')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

Zyklische Colormaps

Zyklische Colormaps beginnen und enden mit derselben Farbe, wodurch sie für Daten geeignet sind, die „umklappen“ – Winkel, Phasen, Tageszeit, Windrichtung.

Wann verwenden: Phasendaten, Kompassrichtungen, periodische Signale, Stunden des Tages.

Wichtige Beispiele: twilight, twilight_shifted, hsv

import matplotlib.pyplot as plt
import numpy as np
 
theta = np.linspace(0, 2 * np.pi, 300)
r = np.linspace(0, 1, 300)
T, R = np.meshgrid(theta, r)
Z = T  # Color represents angle
 
fig, ax = plt.subplots(subplot_kw={'projection': 'polar'}, figsize=(6, 6))
im = ax.pcolormesh(T, R, Z, cmap='twilight', shading='auto')
fig.colorbar(im, ax=ax, label='Angle (radians)')
ax.set_title('Cyclic Colormap: twilight')
plt.show()

Vergleichstabelle: Colormap-Kategorien

Referenz: Integrierte Colormaps

Matplotlib enthält Colormaps aus mehreren Familien. Hier sind die am häufigsten verwendeten nach Kategorie.

Wahrnehmungsuniforme sequentielle Colormaps

Diese Colormaps wurden so entworfen, dass gleiche Datenschritte gleiche Schritte in der wahrgenommenen Helligkeit erzeugen. Sie sind für die meisten Anwendungsfälle die Standardempfehlung.

Beliebte divergierende Colormaps

Colormaps über verschiedene Plot-Typen hinweg verwenden

Heatmaps mit imshow

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.rand(8, 10)
 
fig, ax = plt.subplots(figsize=(10, 6))
im = ax.imshow(data, cmap='YlOrRd', aspect='auto')
ax.set_xlabel('Columns')
ax.set_ylabel('Rows')
ax.set_title('Heatmap with YlOrRd Colormap')
fig.colorbar(im, ax=ax, label='Value')
plt.tight_layout()
plt.show()

Scatter Plots mit Farbkodierung

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
n = 300
x = np.random.randn(n)
y = np.random.randn(n)
distance = np.sqrt(x**2 + y**2)
 
plt.figure(figsize=(8, 6))
sc = plt.scatter(x, y, c=distance, cmap='magma', s=40, alpha=0.8, edgecolors='gray', linewidths=0.3)
plt.colorbar(sc, label='Distance from Origin')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Scatter Plot with magma Colormap')
plt.show()

Contour Plots

import matplotlib.pyplot as plt
import numpy as np
 
x = np.linspace(-3, 3, 200)
y = np.linspace(-3, 3, 200)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)
 
fig, axes = plt.subplots(1, 2, figsize=(13, 5))
 
# Filled contour
cf = axes[0].contourf(X, Y, Z, levels=20, cmap='RdBu')
fig.colorbar(cf, ax=axes[0])
axes[0].set_title('contourf with RdBu')
 
# Line contour with colormap
cl = axes[1].contour(X, Y, Z, levels=15, cmap='plasma')
axes[1].clabel(cl, inline=True, fontsize=8)
axes[1].set_title('contour with plasma')
 
plt.tight_layout()
plt.show()

Pcolormesh für unregelmäßige Gitter

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(0)
x = np.linspace(0, 4, 50)
y = np.linspace(0, 3, 40)
X, Y = np.meshgrid(x, y)
Z = np.exp(-(X - 2)**2 - (Y - 1.5)**2) + 0.5 * np.sin(3 * X) * np.cos(3 * Y)
 
plt.figure(figsize=(9, 6))
pcm = plt.pcolormesh(X, Y, Z, cmap='cividis', shading='auto')
plt.colorbar(pcm, label='Intensity')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('pcolormesh with cividis Colormap')
plt.tight_layout()
plt.show()

Colorbar-Anpassung

Die Colorbar ist die Legende für deine Colormap. Sie sauber anzupassen ist entscheidend für eine gut lesbare Visualisierung.

Grundlegende Colorbar-Optionen

import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(10, 10)
 
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap='viridis')
 
cbar = fig.colorbar(im, ax=ax, orientation='vertical', shrink=0.8, pad=0.02)
cbar.set_label('Measurement Value', fontsize=12)
cbar.ax.tick_params(labelsize=10)
plt.title('Colorbar Customization')
plt.tight_layout()
plt.show()

Diskrete Colorbar mit BoundaryNorm

Wenn deine Daten natürlicherweise in diskrete Klassen fallen (Risikostufen, Bewertungskategorien), nutze BoundaryNorm, um harte Farbgrenzen statt eines glatten Farbverlaufs zu erzeugen.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
data = np.random.rand(10, 10) * 100
 
bounds = [0, 20, 40, 60, 80, 100]
norm = mcolors.BoundaryNorm(bounds, ncolors=256)
 
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap='RdYlGn', norm=norm)
cbar = fig.colorbar(im, ax=ax, ticks=bounds)
cbar.set_label('Score')
ax.set_title('Discrete Colorbar with BoundaryNorm')
plt.tight_layout()
plt.show()

Horizontale Colorbar

import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(8, 12)
 
fig, ax = plt.subplots(figsize=(10, 5))
im = ax.imshow(data, cmap='plasma')
cbar = fig.colorbar(im, ax=ax, orientation='horizontal', fraction=0.046, pad=0.12)
cbar.set_label('Value')
ax.set_title('Horizontal Colorbar')
plt.tight_layout()
plt.show()

Benutzerdefinierte Colormaps erstellen

Wenn die eingebauten Colormaps nicht zu deinen Anforderungen passen – Corporate-Brand-Farben, domänenspezifische Konventionen oder besondere wahrnehmungsbezogene Anforderungen – bietet Matplotlib zwei Klassen, um eigene zu erstellen.

ListedColormap: Aus einer Farbliste

ListedColormap erzeugt eine Colormap aus einer expliziten Liste von Farben. Jede Farbe belegt denselben Anteil des Bereichs [0, 1].

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
# Define colors by name, hex, or RGB tuple
colors = ['#2c3e50', '#2980b9', '#27ae60', '#f39c12', '#e74c3c']
cmap_custom = mcolors.ListedColormap(colors)
 
data = np.random.rand(10, 10)
 
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap=cmap_custom)
fig.colorbar(im, ax=ax)
ax.set_title('Custom ListedColormap (5 colors)')
plt.tight_layout()
plt.show()

LinearSegmentedColormap: Glatte Farbverläufe

LinearSegmentedColormap erzeugt glatte Farbübergänge. Der einfachste Ansatz nutzt from_list, das linear zwischen Ankerfarben interpoliert.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
# Smooth gradient from dark blue through white to dark red
colors = ['#1a1a6e', '#4a90d9', '#ffffff', '#d94a4a', '#6e1a1a']
cmap_diverge = mcolors.LinearSegmentedColormap.from_list('custom_diverge', colors)
 
np.random.seed(42)
data = np.random.randn(12, 12)
 
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap=cmap_diverge, vmin=-3, vmax=3)
fig.colorbar(im, ax=ax, label='Standard Deviations')
ax.set_title('Custom Diverging Colormap')
plt.tight_layout()
plt.show()

Fortgeschritten: Segment-Dictionary-Format

Für volle Kontrolle darüber, wie jeder Farbkanal übergeht, definiere ein Segment-Dictionary. Jeder Kanal (rot, grün, blau) erhält eine Liste von (x, y_left, y_right)-Tupeln, die Ankerpunkte festlegen.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
# Custom colormap: black -> blue -> cyan -> yellow -> white
cdict = {
    'red':   [(0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.5, 0.0, 0.0),
              (0.75, 1.0, 1.0), (1.0, 1.0, 1.0)],
    'green': [(0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.5, 1.0, 1.0),
              (0.75, 1.0, 1.0), (1.0, 1.0, 1.0)],
    'blue':  [(0.0, 0.0, 0.0), (0.25, 1.0, 1.0), (0.5, 1.0, 1.0),
              (0.75, 0.0, 0.0), (1.0, 1.0, 1.0)]
}
cmap_seg = mcolors.LinearSegmentedColormap('custom_seg', cdict)
 
data = np.random.rand(10, 10)
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap=cmap_seg)
fig.colorbar(im, ax=ax)
ax.set_title('Segment Dictionary Colormap')
plt.tight_layout()
plt.show()

Eine benutzerdefinierte Colormap registrieren

Registriere deine Colormap, damit sie in jeder Plot-Funktion per Name referenziert werden kann – genau wie eine eingebaute:

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
 
colors = ['#0d0887', '#7e03a8', '#cc4778', '#f89540', '#f0f921']
my_cmap = mcolors.LinearSegmentedColormap.from_list('my_palette', colors)
plt.colormaps.register(cmap=my_cmap)
 
# Now use it by name anywhere
# plt.imshow(data, cmap='my_palette')

Eine Colormap umkehren

Hänge _r an einen Colormap-Namen an, um die umgekehrte Version zu erhalten. Das ist nützlich, wenn du die visuelle Betonung invertieren möchtest – zum Beispiel, wenn höhere Werte dunkler statt heller sein sollen.

import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(8, 8)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
 
axes[0].imshow(data, cmap='viridis')
axes[0].set_title('viridis (default)')
 
axes[1].imshow(data, cmap='viridis_r')
axes[1].set_title('viridis_r (reversed)')
 
plt.tight_layout()
plt.show()

Jede eingebaute Colormap hat ein umgekehrtes Pendant: plasma_r, coolwarm_r, RdBu_r, inferno_r usw.

Colormap-Teilmengen kürzen und extrahieren

Manchmal brauchst du nur einen Ausschnitt einer Colormap. Nutze Colormap.__call__ mit np.linspace und ListedColormap, um ein Segment zu extrahieren:

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
# Extract the middle 50% of the viridis colormap
full_cmap = plt.colormaps['viridis']
colors = full_cmap(np.linspace(0.25, 0.75, 256))
truncated_cmap = mcolors.ListedColormap(colors)
 
data = np.random.rand(10, 10)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
axes[0].imshow(data, cmap='viridis')
axes[0].set_title('Full viridis')
axes[1].imshow(data, cmap=truncated_cmap)
axes[1].set_title('Truncated viridis (25%-75%)')
plt.tight_layout()
plt.show()

Normalisierung: Steuern, wie Daten auf Farben abgebildet werden

Normalisierung bestimmt, wie rohe Datenwerte vor dem Farbnachschlag in den Bereich [0, 1] überführt werden. Standard ist linear, aber Matplotlib bietet mehrere Alternativen.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
np.random.seed(42)
data = np.random.lognormal(mean=2, sigma=1.5, size=(20, 20))
 
fig, axes = plt.subplots(1, 3, figsize=(16, 5))
 
# Linear (default)
im0 = axes[0].imshow(data, cmap='magma')
fig.colorbar(im0, ax=axes[0])
axes[0].set_title('Linear Normalize')
 
# LogNorm
im1 = axes[1].imshow(data, cmap='magma', norm=mcolors.LogNorm())
fig.colorbar(im1, ax=axes[1])
axes[1].set_title('LogNorm')
 
# PowerNorm (gamma=0.5 = square root)
im2 = axes[2].imshow(data, cmap='magma', norm=mcolors.PowerNorm(gamma=0.5))
fig.colorbar(im2, ax=axes[2])
axes[2].set_title('PowerNorm (gamma=0.5)')
 
plt.tight_layout()
plt.show()

Die richtige Colormap für deine Daten auswählen

Die passende Colormap zu wählen ist eine Designentscheidung mit echten Konsequenzen. Hier ist ein praxisnahes Entscheidungsraster:

1. Sind die Daten sequentiell (niedrig nach hoch)? Verwende eine sequentielle Colormap. Starte mit viridis. Wenn du mehr Kontrast brauchst, probiere plasma oder inferno.

2. Weichen die Daten von einem sinnvollen Zentrum ab? Verwende eine divergierende Colormap. coolwarm für einen subtilen Look, RdBu für starken Kontrast. Setze vmin und vmax symmetrisch.

3. Sind die Daten kategorial ohne Ordnung? Verwende eine qualitative Colormap. tab10 für bis zu 10 Kategorien, tab20 für bis zu 20.

4. „Wickeln“ die Daten (Winkel, Phasen)? Verwende eine zyklische Colormap. twilight ist die beste moderne Option.

5. Gehört Farbsehschwäche zur Zielgruppe? Verwende cividis (sequentiell) oder viridis. Vermeide Rot-Grün-Paare wie RdYlGn.

6. Wird die Grafik in Graustufen gedruckt? Verwende viridis, plasma, inferno oder magma – diese behalten eine monoton steigende Helligkeit bei.

Barrierefreiheit: Farbenblind-freundliche Colormaps

Etwa 8% der Männer und 0,5% der Frauen haben eine Form von Farbsehschwäche, am häufigsten betroffen ist die Unterscheidung von Rot und Grün. Wahrnehmungsuniforme Colormaps (viridis, plasma, inferno, magma, cividis) wurden gezielt so gestaltet, dass sie unter den häufigsten Formen von Farbenblindheit lesbar bleiben.

Colormaps, die du aus Accessibility-Sicht vermeiden solltest: jet, rainbow, RdYlGn, RdYlBu (wenn Rot-Grün-Unterscheidung kritisch ist), hot.

Warum jet schädlich ist: Die jet-Colormap (ein Regenbogen von Blau über Cyan, Grün, Gelb bis Rot) hat wahrnehmungsbedingte Nicht-Uniformitäten, die falsche Grenzen in den Daten erzeugen. Bereiche, die sich im tatsächlichen Wert stark unterscheiden, können ähnlich aussehen, während kleine Unterschiede im Cyan-Grün-Bereich dramatisch wirken. Außerdem versagt sie bei Betrachtern mit Deuteranopie (Rot-Grün-Farbenblindheit) nahezu vollständig.

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.rand(15, 15)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
 
axes[0].imshow(data, cmap='jet')
axes[0].set_title('jet (avoid for scientific use)')
 
axes[1].imshow(data, cmap='cividis')
axes[1].set_title('cividis (colorblind-safe)')
 
plt.tight_layout()
plt.show()

Alle verfügbaren Colormaps auflisten

Um alle Colormaps zu sehen, die in deiner Matplotlib-Version verfügbar sind:

import matplotlib.pyplot as plt
 
# All colormap names, sorted
all_cmaps = sorted(plt.colormaps())
print(f"Total colormaps: {len(all_cmaps)}")
 
# Filter out reversed versions
base_cmaps = [c for c in all_cmaps if not c.endswith('_r')]
print(f"Base colormaps (excluding _r): {len(base_cmaps)}")

Um sie visuell darzustellen:

import matplotlib.pyplot as plt
import numpy as np
 
gradient = np.linspace(0, 1, 256).reshape(1, -1)
 
cmaps_to_show = ['viridis', 'plasma', 'inferno', 'magma', 'cividis',
                 'coolwarm', 'RdBu', 'seismic',
                 'tab10', 'Set1',
                 'twilight']
 
fig, axes = plt.subplots(len(cmaps_to_show), 1, figsize=(10, len(cmaps_to_show) * 0.5))
fig.subplots_adjust(hspace=0.4)
 
for ax, name in zip(axes, cmaps_to_show):
    ax.imshow(gradient, aspect='auto', cmap=name)
    ax.set_ylabel(name, rotation=0, labelpad=80, fontsize=10, va='center')
    ax.set_xticks([])
    ax.set_yticks([])
 
fig.suptitle('Matplotlib Colormap Samples', fontsize=14, y=1.01)
plt.tight_layout()
plt.show()

Interaktive Visualisierung mit PyGWalker

Wenn du Datensätze interaktiv explorierst, kann das manuelle Konfigurieren von Colormaps für jedes Plot dich ausbremsen. PyGWalker (opens in a new tab) ist eine Open-Source-Python-Bibliothek, die jedes pandas- oder polars-DataFrame direkt in Jupyter in eine Tableau-ähnliche interaktive Oberfläche verwandelt. Du kannst Variablen per Drag-and-drop auf Achsen ziehen, Farbkodierungen zuweisen und Visualisierungstypen wechseln – ganz ohne Colormap- oder Plotting-Code von Hand zu schreiben.

import pandas as pd
import pygwalker as pyg
 
# Load your data
df = pd.read_csv('your_data.csv')
 
# Launch the interactive UI -- color encoding, binning, and filtering are all point-and-click
walker = pyg.walk(df)

Das ist besonders nützlich in der explorativen Analyse, wenn du noch entscheidest, welche Variablen du visualisieren möchtest und welche Farbkodierungen Muster am klarsten machen. Sobald du die richtige Visualisierung gefunden hast, kannst du sie jederzeit in Matplotlib mit einer präzisen Colormap-Konfiguration nachbauen.

Häufige Fallstricke und wie du sie vermeidest

FAQ

Was ist eine Colormap in Matplotlib?

Eine Colormap in Matplotlib ist eine Funktion, die skalare numerische Werte auf Farben abbildet. Sie nimmt einen Wert zwischen 0 und 1 und gibt ein RGBA-Farbtuple zurück. Colormaps werden in Funktionen wie imshow, scatter, contourf und pcolormesh verwendet, um Daten mit Farbverläufen zu visualisieren. Du kannst sie über plt.colormaps['name'] abrufen oder den Namen als String an den cmap-Parameter übergeben.

Wie wähle ich die richtige Colormap für meine Daten?

Für sequentielle Daten (niedrig nach hoch) verwende viridis, plasma oder inferno. Für divergierende Daten (Abweichung von einem Zentrum) verwende coolwarm oder RdBu. Für kategoriale Daten verwende tab10 oder Set1. Für zyklische Daten wie Winkel verwende twilight. Denke immer an Barrierefreiheit – viridis und cividis sind für farbenblinde Betrachter sicher.

Wie erstelle ich eine benutzerdefinierte Colormap in Matplotlib?

Nutze matplotlib.colors.ListedColormap, um eine Colormap aus einer Liste spezifischer Farben zu erstellen, oder matplotlib.colors.LinearSegmentedColormap.from_list('name', colors), um einen glatten Verlauf zwischen Ankerfarben zu erzeugen. Registriere sie mit plt.colormaps.register(), um sie per Name zu verwenden.

Wie kehre ich eine Colormap in Matplotlib um?

Hänge _r an einen Colormap-Namen an. Zum Beispiel liefert cmap='viridis_r' die umgekehrte Version von viridis. Das funktioniert für alle eingebauten Colormaps. Für benutzerdefinierte Colormaps rufe die Methode .reversed() auf dem Colormap-Objekt auf.

Warum sollte ich die jet-Colormap vermeiden?

Die jet-Colormap hat wahrnehmungsbedingte Nicht-Uniformitäten, die falsche Grenzen erzeugen und reale Muster in Daten verstecken können. Außerdem versagt sie bei Betrachtern mit Rot-Grün-Farbsehschwäche. Matplotlib hat seinen Standard in Version 2.0 genau wegen dieser Probleme von jet auf viridis umgestellt. Verwende stattdessen viridis, plasma oder cividis.

Wie füge ich einem Matplotlib-Plot eine Colorbar hinzu?

Rufe plt.colorbar(mappable) auf, wobei mappable das Objekt ist, das von imshow, scatter, contourf oder ähnlichen Funktionen zurückgegeben wird. Du kannst sie mit Parametern wie label, orientation ('horizontal' oder 'vertical'), shrink und pad anpassen. Außerdem kannst du über cbar.ax auf die Achse der Colorbar zugreifen, um feingranular zu steuern.

Fazit

Colormaps sind keine dekorative Spielerei – sie sind funktionale Komponenten, die darüber entscheiden, ob deine Visualisierung die Wahrheit verständlich kommuniziert oder in die Irre führt. Matplotlib bietet dir eine große Bibliothek integrierter Colormaps, klar gegliedert in vier Kategorien (sequentiell, divergierend, qualitativ, zyklisch), sowie Werkzeuge, um bei Bedarf vollständig eigene Colormaps zu bauen. Die wahrnehmungsuniforme Familie (viridis, plasma, inferno, magma, cividis) sollte dein Standard-Startpunkt für alle sequentiellen Daten sein. Für divergierende Daten wähle eine Map wie coolwarm oder RdBu und zentriere die neutrale Farbe immer auf den inhaltlich sinnvollen Mittelpunkt deiner Daten. Für Kategorien greif zu tab10 oder Set1. Und denke immer an dein Publikum – farbenblind-freundliche Colormaps zu verwenden ist nicht optional, sondern professionelle Praxis.