5 typische Arten, Matplotlib Colormaps (cmaps) zu verwenden

Name

Elwynn AI

Updated on 15.11.2025

Das Colormap-System (cmap) von Matplotlib ist viel mehr als nur „ein Farbschema auswählen“. Wenn du die API verstehst, kannst du:

• kontinuierliche Werte visualisieren (Heatmaps, Bilder)
• zusätzliche Dimensionen in Scatter-Plots codieren
• diskrete Colormaps für Kategorien erstellen
• nichtlineare Skalierung (log, Grenzen) für schwierige Daten nutzen
• Farben aus einer Colormap sampeln, um eigene Plots zu stylen

In diesem Beitrag gehen wir 5 typische Muster mit Code + echten Diagramm-Ausgaben durch. Du kannst jedes Snippet in dein eigenes Notebook oder Script kopieren.

Alle Beispiele setzen voraus:

import numpy as np
import matplotlib.pyplot as plt

1. Kontinuierliche Colormap mit imshow

Die grundlegendste Nutzung von Colormaps ist die Visualisierung von 2D-Arrays mit imshow – z. B. Heatmaps, Bilder oder beliebige reguläre Gitter.

Code

import numpy as np
import matplotlib.pyplot as plt
 
# Generate some random-ish 2D data
data = np.random.randn(50, 50).cumsum(axis=0)
 
plt.figure()
plt.imshow(data, cmap="viridis")
plt.colorbar()
plt.title("Continuous colormap with imshow (viridis)")
plt.tight_layout()
plt.show()

Diagramm

Du erhältst eine glatte Heatmap mit der perzeptuell gleichmäßigen viridis-Colormap:

(Das entspricht dem ersten Bild oben: eine lila–grüne Heatmap mit Colorbar.)

Wichtige Punkte:

• cmap="viridis" wählt die Colormap.
• plt.colorbar() zeichnet eine Farbskala, damit Betrachter die Werte interpretieren können.
• Beliebige 2D-NumPy-Arrays können an imshow übergeben werden.

2. Scatter-Plot mit Colormap und Colorbar

Du kannst Colormaps verwenden, um eine zusätzliche numerische Dimension in einem Scatter-Plot zu codieren (z. B. Zeit, Intensität, Wahrscheinlichkeit).

Code

import numpy as np
import matplotlib.pyplot as plt
 
np.random.seed(0)
x = np.linspace(0, 10, 200)
y = np.sin(x) + 0.1 * np.random.randn(200)
 
# A separate value for each point, mapped to a colormap
values = np.linspace(0, 1, 200)
 
plt.figure()
scatter = plt.scatter(x, y, c=values, cmap="plasma")
plt.colorbar(scatter, label="value")
plt.title("Scatter with colormap (plasma)")
plt.xlabel("x")
plt.ylabel("sin(x) + noise")
plt.tight_layout()
plt.show()

Diagramm

Du erhältst einen Scatter-Plot, in dem die Punktfarben sanft entlang der plasma-Colormap übergehen, plus eine Colorbar, die erklärt, was die Farben bedeuten.

Wichtige Punkte:

• c=values übergibt die numerischen Daten, die auf Farben abgebildet werden.
• cmap="plasma" wählt die Colormap.
• Übergebe das scatter-Objekt an plt.colorbar(), um eine passende Colorbar zu erhalten.

3. Diskrete Colormap für Kategorien

Colormaps sind standardmäßig kontinuierlich, du kannst sie aber auch verwenden, um eine kleine Menge diskreter Farben für Kategorien zu erzeugen (Klassifikationsergebnisse, Labels usw.).

Code

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
 
# Fake 4-category classification
categories = np.random.randint(0, 4, 100)
x = np.random.randn(100)
y = np.random.randn(100)
 
# Build a discrete colormap from the first 4 colors of tab10
base_cmap = plt.cm.tab10
cmap_disc = ListedColormap(base_cmap(np.linspace(0, 1, 4)))
 
plt.figure()
for i in range(4):
    mask = categories == i
    # Use a single color for each class
    plt.scatter(x[mask], y[mask], c=[cmap_disc(i)], label=f"class {i}")
 
plt.legend()
plt.title("Discrete colormap for categories (tab10 subset)")
plt.xlabel("x")
plt.ylabel("y")
plt.tight_layout()
plt.show()

Diagramm

Du siehst einen Scatter-Plot, bei dem jede Kategorie (0–3) ihre eigene, deutlich unterscheidbare Farbe hat (entnommen aus tab10).

Wichtige Punkte:

• ListedColormap erlaubt dir, eine Colormap aus einer Liste von Farben zu konstruieren.
• Das ist ideal, wenn du eine kleine Anzahl stabiler Kategorienfarben brauchst.
• Wir haben tab10 (eine gute Standard-Qualitative-Colormap) verwendet und 4 Farben daraus genommen.

4. Verwendung von Normalisierung (LogNorm) mit einer Colormap

Manchmal erstrecken sich Daten über mehrere Größenordnungen. Eine lineare Abbildung auf Farben kann dann Struktur verbergen. Stattdessen kombinierst du eine Colormap mit einer Normalisierungsfunktion wie LogNorm.

Code

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm
 
x = np.linspace(0.01, 2, 200)
y = np.linspace(0.01, 2, 200)
X, Y = np.meshgrid(x, y)
Z = np.exp(X * Y)  # Grows very quickly
 
plt.figure()
pcm = plt.pcolormesh(X, Y, Z, norm=LogNorm(), cmap="magma")
plt.colorbar(pcm, label="exp(x * y)")
plt.title("LogNorm with colormap (magma)")
plt.xlabel("x")
plt.ylabel("y")
plt.tight_layout()
plt.show()

Diagramm

Du siehst ein 2D-Feld aus Farben, in dem Bereiche mit kleinen und großen Werten dank der logarithmischen Skalierung (mit magma) gleichzeitig sichtbar werden.

Wichtige Punkte:

• norm=LogNorm() steuert, wie Werte vor dem Anwenden von cmap auf den Bereich [0, 1] abgebildet werden.
• Funktioniert mit pcolormesh, imshow, scatter usw.
• Weitere Norms: Normalize, BoundaryNorm, PowerNorm usw.

5. Farben aus einer Colormap für Linienplots sampeln

Colormaps sind nicht nur für „gefüllte“ Plots da. Du kannst einzelne Farben aus einer Colormap sampeln und überall verwenden – für Linien, Balken, Annotationen usw.

Code

import numpy as np
import matplotlib.pyplot as plt
 
cmap = plt.cm.cividis   # choose any colormap you like
xs = np.linspace(0, 10, 200)
 
plt.figure()
for i, freq in enumerate(np.linspace(0.5, 2.5, 6)):
    ys = np.sin(freq * xs)
    color = cmap(i / 5.0)   # sample evenly across the colormap
    plt.plot(xs, ys, label=f"freq={freq:.1f}", color=color)
 
plt.legend(title="frequency")
plt.title("Sampling colors from colormap (cividis)")
plt.xlabel("x")
plt.ylabel("sin(freq * x)")
plt.tight_layout()
plt.show()

Diagramm

Du erhältst mehrere Sinuswellen, jede mit einer anderen Farbe aus cividis, die sich glatt entlang der Colormap verändert.

Wichtige Punkte:

• plt.cm.<name> gibt dir ein Colormap-Objekt, das du wie eine Funktion aufrufen kannst.
• cmap(t) liefert eine RGBA-Farbe für t im Bereich [0, 1].
• Das ist eine elegante Möglichkeit, konsistente und ästhetische Farbpaletten zu erzeugen.

Fazit

Diese 5 Muster decken einen großen Teil der Alltagsnutzung von Matplotlib-Colormaps ab:

1. Kontinuierliche Heatmaps mit imshow + cmap.
2. Scatter-Plots, in denen Farbe eine zusätzliche Wertdimension kodiert.
3. Diskrete Kategorienfarben mit ListedColormap.
4. Nichtlineare Skalierung mit LogNorm (und anderen) + Colormaps.
5. Farben sampeln aus einer Colormap für individuelles Styling (Linien, Balken usw.).

Wenn du damit vertraut bist, kannst du weiter erkunden:

• Eigene Colormaps (aus deinen eigenen Farblisten oder externen Tools)
• BoundaryNorm für diskrete Wertebereiche (z. B. Bins)
• perzeptuell uniforme Colormaps (viridis, plasma, cividis usw.) für bessere Lesbarkeit und Barrierefreiheit