Matplotlib Colormaps: Anpassen deiner Farbschemata

Datenvisualisierung ist eine der besten Möglichkeiten (wenn nicht sogar die beste) für Datenanalysten und Datenwissenschaftler, komplexe Informationen darzustellen und aussagekräftige Erkenntnisse zu gewinnen. Damit du das Beste aus der Kommunikation mit deinen Stakeholdern machen kannst, habe ich hilfreiche Informationen über Matplotlib-Farbkarten zusammengestellt. 

Wie du in diesem Artikel sehen wirst, ist Matplotlib eine extrem vielseitige und erweiterbare Visualisierungsbibliothek in Python. Es bietet alle Möglichkeiten, von einfachen Diagrammen bis hin zu vollständig interaktiven Darstellungen. Wenn du noch nicht mit Python vertraut bist, empfehle ich dir, unseren Kurs "Einführung in Python " zu besuchen, bevor wir loslegen, um die Grundlagen zu verstehen. Ich persönlich habe auch das Python Cheat Sheet immer griffbereit, weil es eine nützliche Referenz für gängige Funktionen ist.

Die Wahl der richtigen Matplotlib-Farbkarte

Eines der ersten Dinge, die du beachten musst, ist die Entscheidung zwischen sequentiellen, divergierenden oder kategorischen Farbkarten. Weitere wichtige Faktoren, die du bei der Auswahl von Farbkarten berücksichtigen solltest, sind die Gleichmäßigkeit der Wahrnehmung, d. h., dass gleiche Unterschiede in den Datenwerten als gleiche Unterschiede in der Farbe wahrgenommen werden, und die Verwendung von farbenblindenfreundlichen Farbkartenoptionen, um deine Grafiken für alle Zielgruppen zugänglich zu machen.

Bei der Auswahl der Farbkarten solltest du auch verschiedene Domain-Standards berücksichtigen. In ozeanografischen Studien stehen verschiedene Blautöne beispielsweise für unterschiedliche Wassertiefen. Wenn du dir nicht sicher bist, welche Farbkarte für deine Visualisierung die richtige ist, gibt es verschiedene Tools und Ressourcen, die dir helfen können. Insbesondere unser eigener Kurs Einführung in die Datenvisualisierung mit Matplotlib hilft dir, viele Szenarien durchzuarbeiten.

Verschiedene Colormaps in Matplotlib

In Python bietet das Modul matplotlib.colormaps Zugang zu eingebauten Farbkarten, mit denen du das beste Schema für dein Projekt auswählen kannst. Im Folgenden sind die häufigsten Kategorien von Optionen aufgeführt:

Sequentielle Farbkarten

Sequentielle Farbkarten stellen geordnete Daten dar, die sich von niedrigen zu hohen Werten entwickeln. Sie gehen von hellen zu dunklen Farbtönen über und zeigen die Größe der Daten auf verschiedenen Ebenen. Ein Beispiel für eine sequenzielle Farbkarte sind Heatmaps für Temperaturdaten, bei denen hellere Farben kühlere Temperaturen und dunklere Schattierungen heißere Temperaturen darstellen.

Angenommen, du hast einen Datensatz mit Datums- und Temperaturspalten. Der folgende Code erstellt eine Heatmap für die Temperatur.

# Import required libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

# Step 1: Extract month and day information from the date column
calendar_data = temperature_data.copy()   # Create a copy to work with
calendar_data['Month'] = calendar_data['Date'].dt.strftime('%B')
calendar_data['Day'] = calendar_data['Date'].dt.day

# Step 2: Define the order of months for a natural calendar sequence
month_names = ['January', 'February', 'March', 'April', 'May', 'June', 
               'July', 'August', 'September', 'October', 'November', 'December']

# Convert the 'Month' column to a categorical type with the specified order
calendar_data['Month'] = pd.Categorical(calendar_data['Month'], categories=month_names, ordered=True)

# Step 3: Pivot the data to create a structured table for the heatmap
monthly_temperature_table = calendar_data.pivot(index='Month', columns='Day', values='Temperature')

# Step 4: Set up the plot for the heatmap
plt.figure(figsize=(12, 8))

# Define a custom normalization for temperature range (optional)
norm = mcolors.Normalize(vmin=15, vmax=35)

# Create the heatmap with a sequential colormap
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Add color bar to represent temperature
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Label the axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Set y-ticks to display month names instead of numbers
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Add a title to the heatmap
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Display the plot
plt.grid(False)
plt.show()

Beispiel für die Visualisierung sequenzieller Farbkarten in Matplotlib. Bild vom Autor

Divergierende Farbkarten

Divergierende Farbkarten heben Daten hervor, die in beide Richtungen von einem zentralen Wert abweichen. Die abweichenden Farbkarten haben kontrastierende Farben für die positive und negative Richtung. Eine häufige Anwendung von divergierenden Farbkarten sind Finanzdaten zur Darstellung von Gewinn und Verlust.

# Set 'Month' as the index
monthly_profit_loss_data.set_index('Month', inplace=True)

# Set the figure size
plt.figure(figsize=(8, 4))

# Create a diverging heatmap using Seaborn
# Use 'RdYlGn' colormap for diverging colors (Red for loss, Green for profit)
sns.heatmap(monthly_profit_loss_data.T, cmap='RdYlGn', center=0, annot=True, fmt='.0f', cbar_kws={'label': 'Profit/Loss ($)'})

# Add labels for the axes
plt.xlabel('Month')
plt.ylabel('')

# Add a title
plt.title('Profit/Loss Heatmap (Diverging Colormap)')

# Display the plot
plt.show()

Beispiel für die Visualisierung einer divergierenden Farbkarte in Matplotlib. Bild vom Autor.

Zyklische Farbkarten

Zyklische Farbkarten sind nützlich, um Daten zu visualisieren, die ein sich wiederholendes oder zyklisches Muster darstellen, wie zum Beispiel Winkel, Wellenphasen oder Tageszeiten. Ein Beispiel für eine zyklische Farbkarte in Aktion ist die Visualisierung der Phasen einer periodischen Funktion, z. B. einer Sinuswelle.

# Create data for a sine wave
x = np.linspace(0, 2 * np.pi, 100)  # X values from 0 to 2π (one complete cycle)
y = np.sin(x)  # Y values (sine of X)

# Create a figure and axis
plt.figure(figsize=(10, 6))

# Create a scatter plot with a cyclic colormap
# Color points by their position in the sine wave cycle
points = plt.scatter(x, y, c=x, cmap='twilight', edgecolor='black')

# Add a color bar to show the phase of the wave
cbar = plt.colorbar(points)
cbar.set_label('Wave Phase (Radians)', rotation=270, labelpad=15)

# Label the axes
plt.xlabel('Angle (Radians)')
plt.ylabel('Sine Value')

# Add a title
plt.title('Sine Wave with Cyclic Colormap (Twilight)')

# Display the plot
plt.grid(True)
plt.show()

Beispiel für die Visualisierung einer zyklischen Farbkarte in Matplotlib. Bild vom Autor.

Qualitative Farbkarten

Qualitative Farbkarten sind ideal, um kategoriale Daten darzustellen, ohne dass die Kategorien eine bestimmte Reihenfolge haben. Ein häufiger Anwendungsfall für qualitative Farbkarten ist ein Tortendiagramm, bei dem jedes Segment eine andere Kategorie darstellt, die sich leicht unterscheiden lässt.

# Sample categorical data
categories = ['Category A', 'Category B', 'Category C', 'Category D', 'Category E']
values = [20, 35, 25, 10, 10]

# Set the figure size
plt.figure(figsize=(8, 8))

# Define a qualitative colormap manually (similar to 'Set3' in Seaborn)
colors = ['#8dd3c7', '#ffffb3', '#bebada', '#fb8072', '#80b1d3']  # Manually selected color hex codes

# Create a pie chart
plt.pie(values, labels=categories, autopct='%1.1f%%', startangle=90, colors=colors)

# Equal aspect ratio ensures the pie is drawn as a circle
plt.axis('equal')

# Add a title
plt.title('Pie Chart with Qualitative Colormap')

# Display the chart
plt.show()

Beispiel für eine qualitative Farbkartenvisualisierung mit Matplotlib. Bild vom Autor.

Regenbogen-Farbkarten

Regenbogenfarbkarten wie hsv werden verwendet, wenn eine breite Palette von Farbtönen benötigt wird.

# Generate cyclic data
x = np.linspace(0, 2 * np.pi, 500)
y = np.sin(x)

# Create a plot with rainbow colormap
plt.scatter(x, y, c=x, cmap='hsv', s=50)

# Add a color bar
plt.colorbar(label='Phase')

# Add labels and title
plt.xlabel('Angle (radians)')
plt.ylabel('Sine Value')
plt.title('Cyclic Data Visualization using HSV Colormap')

# Display the plot
plt.show()

Matplotlib Beispiel für die Visualisierung einer Regenbogenfarbkarte. Bild vom Autor.

Wahrnehmungsmäßig einheitliche Farbkarten

Farbkarten wie inferno und plasma bieten eine bessere Sichtbarkeit über verschiedene Anzeigemedien hinweg.

# Generate synthetic elevation data
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2)) * 100  # Elevation data

# Plot the elevation data using the 'plasma' colormap
plt.contourf(X, Y, Z, cmap='plasma')

# Add a color bar
plt.colorbar(label='Elevation (m)')

# Add title and labels
plt.title('Topographic Map (Plasma Colormap)')
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')

# Display the plot
plt.show()

Matplotlib Beispiel für die Visualisierung einer wahrnehmungsabhängigen Farbkarte. Bild vom Autor.

Erstellen und Ändern von Matplotlib Colormaps

Obwohl Matplotlib eine große Auswahl an integrierten Farbkarten hat, gibt es Szenarien, in denen du deine Farben anpassen möchtest. Die wichtigsten Werkzeuge zum Erstellen eigener Farbkarten in Matplotlib sind ListedColormap und LinearSegmentedColormap.

Erstellen einer benutzerdefinierten Farbkarte mit ListedColormap

ListedColomap ermöglicht es dir, eine Farbkarte aus einer Liste von bestimmten Farben zu erstellen. Diese Methode ist nützlich, wenn du bestimmten Kategorien in kategorialen Daten bestimmte Farben zuordnen willst. 

from matplotlib.colors import ListedColormap

# Categorical data
categories = ['Category A', 'Category B', 'Category C', 'Category D']
values = [25, 40, 35, 30]

# Custom color list for the colormap (e.g., shades of blue, green, red, and purple)
custom_colors = ['#1f77b4', '#2ca02c', '#d62728', '#9467bd']

# Create a ListedColormap using the custom colors
custom_cmap = ListedColormap(custom_colors)

# Set the figure size
plt.figure(figsize=(8, 6))

# Create a bar plot with the custom colormap
bars = plt.bar(categories, values, color=custom_cmap.colors)

# Add a title
plt.title('Bar Chart with Custom ListedColormap')

# Label the axes
plt.xlabel('Categories')
plt.ylabel('Values')

# Display the plot
plt.show()

Matplotlib benutzerdefinierte Farbkarte mit ListedColormap. Bild vom Autor.

Erstellen einer benutzerdefinierten Farbkarte mit LinearSegmentedColormap

LinearSegmentedColormap ermöglicht es dir, Farbkarten zu erstellen, die fließend zwischen den Farben übergehen. Das ist wissenswert, weil kontinuierliche Daten oft Farbverläufe erfordern. Hier gebe ich auch die Anzahl der Intervalle an, die ich für mein Bildmaterial haben möchte.

from matplotlib.colors import LinearSegmentedColormap

# Create a grid of values for a 2D Gaussian function
x = np.linspace(-2, 2, 500)
y = np.linspace(-2, 2, 500)
X, Y = np.meshgrid(x, y)
Z = np.exp(- (X**2 + Y**2))

# Define a custom colormap that transitions from blue to white to red
colors = ['blue', 'white', 'red']
custom_cmap = LinearSegmentedColormap.from_list('blue_white_red', colors)

# Adjust the number of color classes (discrete levels)
# Specify the number of levels (e.g., 10 for 10 distinct color bands)
num_classes = 10
levels = np.linspace(Z.min(), Z.max(), num_classes)

# Set the figure size
plt.figure(figsize=(8, 6))

# Plot the 2D Gaussian function with the adjusted colormap
contour = plt.contourf(X, Y, Z, levels=levels, cmap=custom_cmap)

# Add a color bar to show the discrete color classes
plt.colorbar(contour, label='Gaussian Function Value')

# Add labels for the axes
plt.xlabel('X')
plt.ylabel('Y')

# Add a title
plt.title(f'2D Gaussian with {num_classes} Discrete Color Classes')

# Display the plot
plt.show()

Matplotlib passt die Anzahl der Farbklassen an. Bild vom Autor.

Farbbereiche und Intensität anpassen

Du kannst die Intensität oder den Bereich der Farben in einer bestehenden Farbkarte steuern, indem du ihre Normalisierung veränderst oder sie zerschneidest, um eine Teilmenge der verfügbaren Farben zu verwenden. Im folgenden Beispiel werden die Farbbereiche so aufgeteilt, dass sie Temperaturen zwischen 16 und 40 Grad Celsius anzeigen.

# Set up the plot for the heatmap
plt.figure(figsize=(12, 8))

# Define a custom normalization for temperature range
norm = mcolors.Normalize(vmin=16, vmax=40)

# Create the heatmap with a sequential colormap
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Add color bar to represent temperature
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Label the axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Set y-ticks to display month names instead of numbers
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Add a title to the heatmap
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Display the plot
plt.grid(False)
plt.show()

Matplotlib zur Anpassung von Farbbereichen und Intensität. Bild vom Autor.

Kombinieren bestehender Farbkarten

Du kannst auch bestehende Farbkarten miteinander kombinieren, indem du mehrere Farbkarten mischst, um komplexere Visualisierungen zu erstellen.

from matplotlib.colors import LinearSegmentedColormap, Normalize

# Create synthetic elevation data
x = np.linspace(-180, 180, 500)  # Longitude
y = np.linspace(-90, 90, 250)    # Latitude
X, Y = np.meshgrid(x, y)
Z = 5000 * np.sin(np.sqrt(X**2 + Y**2) * np.pi / 180)  # Synthetic elevation data

# Define the base colormaps ('viridis' and 'cividis')
cmap1 = plt.get_cmap('viridis')
cmap2 = plt.get_cmap('cividis')

# Create a custom colormap by blending the two base colormaps
def blend_colormaps(cmap1, cmap2, blend_ratio=0.5):
    """Blend two colormaps together."""
    c1 = cmap1(np.linspace(0, 1, 256))
    c2 = cmap2(np.linspace(0, 1, 256))
    blended_colors = (1 - blend_ratio) * c1 + blend_ratio * c2
    return LinearSegmentedColormap.from_list('blended_cmap', blended_colors)

# Create the blended colormap
custom_cmap = blend_colormaps(cmap1, cmap2, blend_ratio=0.5)

# Normalize the data for visualization
norm = Normalize(vmin=-5000, vmax=5000)

# Set the figure size
plt.figure(figsize=(12, 6))

# Plot the synthetic elevation data with the blended colormap
contour = plt.contourf(X, Y, Z, levels=100, cmap=custom_cmap, norm=norm)

# Add a color bar to show the blended color mapping
plt.colorbar(contour, label='Elevation (meters)')

# Add labels for the axes
plt.xlabel('Longitude')
plt.ylabel('Latitude')

# Add a title
plt.title('Geographical Elevation Data with Blended Colormap (Viridis + Cividis)')

# Display the plot
plt.show()

Matplotlib Kombinieren vorhandener Farbkarten. Bild vom Autor.

Umkehrung von Farbkarten mit dem Suffix _r

Du kannst jede Colormap in Matplotlib umkehren, indem du das Suffix _r an ihren Namen anhängst.

# Import required libraries
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

# Set up the plot for the heatmap
plt.figure(figsize=(12, 8))

# Create a custom normalization for the color range
norm = mcolors.Normalize(vmin=16, vmax=40)

# Set the figure size
plt.figure(figsize=(12, 8))

# Create a heatmap with a sequential colormap
ax = sns.heatmap(temperature_pivot, cmap='YlOrRd_r', cbar=True, square=True, norm=norm, cbar_kws={'orientation': 'horizontal'})

# Add labels for the axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Add a color bar label (temperature in °C)
colorbar = ax.collections[0].colorbar
colorbar.set_label('Temperature (°C)', labelpad=10)

# Add a title
plt.title('Temperature Heatmap (Sequential Colormap)')

# Display the plot
plt.show()

Matplotlib Umkehrung von Farbkarten mit dem Suffix _r. Bild vom Autor.

Umgang mit häufigen Fehlern in Matplotlib Colormaps

Bei der Arbeit mit Colormaps in Matplotlib können Fehler auftreten, die deinen Arbeitsablauf beeinträchtigen. Im Folgenden findest du einige der Fehler und wie du sie beheben kannst.

AttributeError: Modul 'matplotlib' hat kein Attribut 'colormaps'.

Dieser Fehler tritt auf, wenn du Matplotlib-Versionen vor 3.4.0 verwendest, um auf matplotlib.colormaps zuzugreifen. Das Attribut colormaps wurde in Matplotlib 3.4.0 eingeführt. Überprüfe zunächst deine Matplotlib-Version mit dem unten stehenden Code, um den Fehler zu beheben.

import matplotlib
print(matplotlib.__version__)

Aktualisiere mit dem folgenden Pip-Befehl.

pip install --upgrade matplotlib

Wenn du Probleme hast, deine Matplotlib-Version zu aktualisieren, versuche die folgende Methode, um auf Colormaps zuzugreifen.

plt.get_cmap('viridis')  # instead of matplotlib.colormaps['viridis']

Falsche Farbzuweisungen

Es kann zu falschen Farbzuweisungen kommen, wenn du einen Wert außerhalb des erwarteten Bereichs übergibst oder wenn die Farbzuordnung nicht korrekt angewendet wird. Eine falsche Farbzuweisung kann auch entstehen, wenn die Farbkarte für kontinuierliche Daten gedacht ist, aber auf kategoriale Daten angewendet wird oder umgekehrt.

Um sicherzustellen, dass deine Daten innerhalb des erwarteten Bereichs liegen, normalisiere oder skaliere sie immer mit den Parametern vmax und vmin.

import matplotlib.colors as mcolors

# Create a sample temperature dataset
data = np.random.rand(10, 10) * 100  # Adjust the range to match your data

# Create a color normalization instance to scale the data to the colormap's range
norm = mcolors.Normalize(vmin=0, vmax=100)

# Create a heatmap using the 'viridis' colormap and the specified normalization
plt.imshow(data, cmap='viridis', norm=norm, interpolation='nearest')
plt.colorbar()
plt.show()

Für eine feinere Steuerung kannst du die Farbgrenzen explizit mit den Parametern boundaries oder norm in den Plotfunktionen festlegen.

Visuelle Artefakte und unerwartete Ergebnisse

Wenn du mit diskreten oder niedrig aufgelösten Daten arbeitest, kann es zu ungewollten Farbstreifen, übermäßigem Kontrast oder Farbverläufen kommen. Das Problem tritt auf, wenn deine Daten einen begrenzten Bereich haben, aber mit einer kontinuierlichen Farbkarte angezeigt werden.

Um dieses Problem zu lösen, verwende mehr Datenpunkte oder passe die Anzahl der Farbstufen an, um die Übergänge zu glätten.

# Increase the number of bins in the colormap
cmap = plt.get_cmap('viridis', 256)
plt.imshow(data, cmap=cmap)

Du kannst die Farbkarte in feste Ebenen aufteilen, um gegebenenfalls diskrete Daten zu verarbeiten.

cmap = plt.get_cmap('inferno', 10)  # Divide colormap into 10 discrete levels
plt.imshow(data, cmap=cmap)

Du kannst auch die Anzeigeeinstellungen überprüfen und die Auflösung anpassen, insbesondere wenn du die Visualisierungen speicherst, um Diagramme mit niedriger Auflösung zu vermeiden.

plt.savefig('plot.png', dpi=300)  # Save the figure with a higher resolution

Farbverzerrung durch Clipping

Farbverzerrungen treten auf, wenn Daten extreme Werte außerhalb des erwarteten Farbbereichs enthalten. Dadurch werden Teile der Daten abgeschnitten und mit der minimalen oder maximalen Farbe in der Farbkarte versehen.

Um Farbverfälschungen zu vermeiden, stellst du die Farbgrenzen mit vmin und vmax so ein, dass sie mit dem Bereich deiner Daten übereinstimmen und ein Clipping verhindern.

plt.imshow(data, cmap='plasma', vmin=0, vmax=100)

Du solltest auch eine robuste Skalierung verwenden, um mit Ausreißern umzugehen, indem du benutzerdefinierte Grenzen festlegst, die Extremwerte ausschließen.

import numpy as np
robust_vmin, robust_vmax = np.percentile(data, [2, 98])  # Use percentiles to remove extreme outliers
plt.imshow(data, cmap='inferno', vmin=robust_vmin, vmax=robust_vmax)

Farbkarte wird in 3D-Diagrammen nicht korrekt angezeigt

Wenn es ein Problem damit gibt, wie die Daten in der 3D-Oberfläche abgebildet werden, werden die Farbkarten in den 3D-Visualisierungen möglicherweise nicht richtig angezeigt. Um das Problem zu lösen, stelle sicher, dass die Daten der Z-Achse normalisiert sind und in den erwarteten Bereich der Farbkarte passen. Verwende außerdem die entsprechenden Farbkartengrenzen, um den gesamten Bereich der Z-Werte zu erfassen.

from mpl_toolkits.mplot3d import Axes3D

# Generate sample data for a 3D surface plot
X, Y = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = np.sin(np.sqrt(X**2 + Y**2))

# Create a 3D axes object
ax = plt.axes(projection='3d')

# Plot the surface using the 'viridis' colormap and adjusting the color limits
ax.plot_surface(X, Y, Z, cmap='viridis', vmin=np.min(Z), vmax=np.max(Z))
plt.show()

Fazit

Die Wahl der richtigen Farbkarte ist ein wichtiger Schritt, denn sie hat großen Einfluss darauf, wie die Nutzer deine Daten sehen und verstehen. Meiner Meinung nach ist es ein großer Fehler, viel Zeit in die Datenanalyse zu investieren, während man im letzten Schritt, dem Teil, in dem man seine Ergebnisse kommuniziert, schlampig arbeitet.

Zum Glück bietet Matplotlib viele Optionen, um sicherzustellen, dass deine Bilder eine überzeugende Geschichte erzählen. Melde dich für unseren Kurs Einführung in die Datenvisualisierung mit Matplotlib an, um ein Experte zu werden. Wenn du Python verwendest und auch Seaborn für die Visualisierung nutzt (es ist gut, beides zu kennen), solltest du unsere Kurzanleitung zum Auswählen von Farben in Seaborn lesen und sie mit unserem Kurs Einführung in die Datenvisualisierung mit Seaborn ergänzen.