Matplotlib Farbstufen: Anpassen Ihrer Farbschemata

Datenvisualisierung ist eine der besten Möglichkeiten (wenn nicht die beste Methode) für Datenanalysten und Datenwissenschaftler, komplexe Informationen darzustellen und.sinvolle Einblicke zu generieren. Um das Beste aus Ihrer Möglichkeit zu machen, mit Beteiligten zu kommunizieren, habe ich nützliche Informationen über Matplotlib-Farbbereiche zusammengestellt.

Wie Sie in diesem Artikel sehen werden, ist Matplotlib eine äußerst vielseitige und erweiterbare Visualisierungsbibliothek in Python. Es bietet jede Option, von einfachen Diagrammen bis hin zu完全 interaktiven Visualisierungen. Wenn Sie sich im Allgemeinen nicht mit Python vertraut machen, rate ich Ihnen, sich in unseren Einführung in Python-Kurs einzuschreiben, bevor wir beginnen, um seine Grundlagen zu verstehen. Persönlich halte ich auch die Python-Schnellreferenz griffbereit, da sie eine nützliche Referenz für häufig verwendete Funktionen ist.

Die richtige Wahl der Matplotlib-Farbbereiche

Eine der ersten Überlegungen ist es, sich zwischen sequenziellen, divergierenden oder kategorischen Farbbereichen zu entscheiden. Weitere wichtige Faktoren, die bei der Wahl von Farbbereichen berücksichtigt werden sollten, sind die wahrnehmungsbezogene Uniformität, das bedeutet, dass gleiche Differenzen in den Datenwerten als gleiche Farbdifferenzen wahrgenommen werden, sowie die Nutzung von farbenblindenfreundlichen Farbbereichsoptionen, um Ihre Visualisierungen für alle Zielgruppen zugänglich zu machen.

Bei der Auswahl von Farbbereichen sollten Sie auch verschiedene Domänenstandards berücksichtigen. Zum Beispiel repräsentieren verschiedene Blautöne in ozeanografischen Studien unterschiedliche Wassertiefen. Wenn Sie sich nicht sicher sind, welcher Farbbereich für Ihre Visualisierung am besten geeignet ist, gibt es verschiedene Tools und Ressourcen zur Verfügung, die Ihnen Orientierung bieten. Besonders unser eigener Kurs Einführung in die Datenvisualisierung mit Matplotlib hilft Ihnen, viele Szenarien durchzuarbeiten.

Unterschiedliche Farbbereiche in Matplotlib

In Python bietet das Modul matplotlib.colormaps Zugang zu eingebauten Farbbereichen, was Ihnen bei der Auswahl des besten Schemas für Ihr Projekt hilft. Die folgenden sind die häufigsten Kategorien von Optionen:

Sequenzielle Farbbereiche

Sequenzielle Farbbalken repräsentieren geordnete Daten, die von niedrigen zu hohen Werten fortschreiten. Sie wechseln von hellen zu dunklen Tönen und zeigen die Datenmagnitude auf verschiedenen Ebenen. Ein Beispiel für eine sequenzielle Farbbalken ist in Heatmaps für Temperaturdaten, bei denen hellere Farben kühlere Temperaturen und dunklere Schattierungen wärmere Temperaturen darstellen.

Angenommen, Sie haben einen Datensatz mit Spalten für Datum und Temperatur. Der folgende Code erstellt eine Heatmap für die Temperatur.

# Importieren der erforderlichen Bibliotheken
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

# Schritt 1: Monat und Tag aus der Datums-spalte extrahieren
calendar_data = temperature_data.copy()   # Eine Kopie erstellen, um damit zu arbeiten
calendar_data['Month'] = calendar_data['Date'].dt.strftime('%B')
calendar_data['Day'] = calendar_data['Date'].dt.day

# Schritt 2: Die Reihenfolge der Monate für eine natürliche Kalenderabfolge definieren
month_names = ['January', 'February', 'March', 'April', 'May', 'June', 
               'July', 'August', 'September', 'October', 'November', 'December']

# Die 'Monat'-Spalte in einen kategorischen Typ mit der angegebenen Reihenfolge umwandeln
calendar_data['Month'] = pd.Categorical(calendar_data['Month'], categories=month_names, ordered=True)

# Schritt 3: Die Daten anordnen, um eine strukturierte Tabelle für die Heatmap zu erstellen
monthly_temperature_table = calendar_data.pivot(index='Month', columns='Day', values='Temperature')

# Schritt 4: Das Diagramm für die Heatmap einrichten
plt.figure(figsize=(12, 8))

# Eine benutzerdefinierte Normalisierung für den Temperaturbereich festlegen (optional)
norm = mcolors.Normalize(vmin=15, vmax=35)

# Die Heatmap mit einer sequenziellen Farbskala erstellen
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Eine Farbbalken hinzufügen, um die Temperatur darzustellen
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Die Achsen beschriften
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Die y-Achsenbeschriftungen so einstellen, dass sie Monatsnamen anstelle von Zahlen anzeigen
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Eine Überschrift zur Heatmap hinzufügen
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Das Diagramm anzeigen
plt.grid(False)
plt.show()

Matplotlib sequenzielle Farbskala Visualisierung Beispiel. Bild vom Autor

Abweichende Farbskalen

Abweichende Farbbereiche heben Daten mit Abweichungen von einem zentralen Wert in beide Richtungen hervor. Die abweichenden Farbbereiche haben kontrastreiche Farben für die positiven und negativen Richtungen. Eine häufige Anwendung von abweichenden Farbbereichen ist in Finanzdaten zur Darstellung von Gewinn und Verlust.

# Setze 'Monat' als Index
profit_loss_df.set_index('Month', inplace=True)

# Setze die Abbildungsgröße
plt.figure(figsize=(8, 4))

# Erstelle einen abweichenden Farbbereich
cmap = plt.cm.RdYlGn

# Zeige die Daten als Heatmap mit imshow an
im = plt.imshow(profit_loss_df.T, cmap=cmap, aspect='auto', vmin=-np.max(np.abs(profit_loss_data)), vmax=np.max(np.abs(profit_loss_data)))

# Füge eine Farbpalette mit Beschriftung hinzu
cbar = plt.colorbar(im)
cbar.set_label('Profit/Loss ($)')

# Füge Annotationen in jede Zelle ein
for i, month in enumerate(profit_loss_df.index):
    plt.text(i, 0, f'{profit_loss_df.loc[month, "Profit/Loss"]:.2f}', ha='center', va='center', color='black')

# Setze Beschriftungen und Markierungen für die x-Achse und y-Achse
plt.xlabel('Month')
plt.ylabel('')  # Keine Beschriftung für die y-Achse erforderlich
plt.xticks(ticks=range(len(profit_loss_df.index)), labels=profit_loss_df.index, rotation=45)
plt.yticks([])  # Verberge die y-Achsenmarkierungen, da wir nur eine Zeile haben

# Füge eine Überschrift hinzu
plt.title('Profit/Loss Heatmap (Diverging Colormap)')

# Passe das Layout für eine bessere Anzeige an
plt.tight_layout()

# Zeige das Diagramm an
plt.show()

Matplotlib abweichender Farbbereich Visualisierung Beispiel. Bild vom Autor.

Zyklische Farbbalken

Zyklische Farbbalken sind nützlich zur Visualisierung von Daten, die ein wiederholendes oder zyklisches Muster darstellen, wie Winkel, Wellenphasen oder Tageszeit. Ein Beispiel für die Anwendung eines zyklischen Farbbalkens ist die Visualisierung der Phasen einer periodischen Funktion, wie einer Sinuskurve.

# Erstellen von Daten für eine Sinuskurve
x = np.linspace(0, 2 * np.pi, 100)  # X-Werte von 0 bis 2π (ein vollständiger Zyklus)
y = np.sin(x)  # Y-Werte (Sinus von X)

# Erstellen eines Diagramms und einer Achse
plt.figure(figsize=(10, 6))

# Erstellen eines Scatter-Plots mit einem zyklischen Farbbalken
# Farbige Punkte nach ihrer Position im Sinuswellenzyklus
points = plt.scatter(x, y, c=x, cmap='twilight', edgecolor='black')

# Hinzufügen einer Farbgleiter, um die Phase der Welle anzuzeigen
cbar = plt.colorbar(points)
cbar.set_label('Wave Phase (Radians)', rotation=270, labelpad=15)

# Achsen beschriften
plt.xlabel('Angle (Radians)')
plt.ylabel('Sine Value')

# Hinzufügen einer Überschrift
plt.title('Sine Wave with Cyclic Colormap (Twilight)')

# Anzeigen des Diagramms
plt.grid(True)
plt.show()

Matplotlib zyklische Farbbalken-Visualisierung Beispiel. Bild vom Autor.

Qualitative Farbbalken

Qualitative Colormaps sind ideal, um kategoriale Daten darzustellen, bei denen es keine bestimmte Reihenfolge der Kategorien gibt. Ein häufiger Anwendungsfall von qualitativen Colormaps ist ein Tortendiagramm, bei dem jeder Segment eine verschiedene Kategorie darstellt, die leicht unterschieden werden kann.

# Beispielsweise kategoriale Daten
categories = ['Category A', 'Category B', 'Category C', 'Category D', 'Category E']
values = [20, 35, 25, 10, 10]

# Größe des Diagramms festlegen
plt.figure(figsize=(8, 8))

# Eine qualitative Colormap manuell definieren
colors = ['#8dd3c7', '#ffffb3', '#bebada', '#fb8072', '#80b1d3']  # Manuell ausgewählte Farbe-Hex-Codes

# Ein Tortendiagramm erstellen
plt.pie(values, labels=categories, autopct='%1.1f%%', startangle=90, colors=colors)

# Gleiche Seitenverhältnisse stellen sicher, dass der Kuchen als Kreis gezeichnet wird
plt.axis('equal')

# Eine Überschrift hinzufügen
plt.title('Pie Chart with Qualitative Colormap')

# Das Diagramm anzeigen
plt.show()

Matplotlib qualitative Colormap Visualisierungsbeispiel. Bild vom Autor.

Regenbogen Colormaps

Regenbogen Colormaps wie hsv werden verwendet, wenn ein breites Spektrum an Farbnuancen erforderlich ist.

# Generiere zyklische Daten
x = np.linspace(0, 2 * np.pi, 500)
y = np.sin(x)

# Erstelle ein Diagramm mit Regenbogen-Farben
plt.scatter(x, y, c=x, cmap='hsv', s=50)

# Füge eine Farbleiste hinzu
plt.colorbar(label='Phase')

# Füge Beschriftungen und Titel hinzu
plt.xlabel('Angle (radians)')
plt.ylabel('Sine Value')
plt.title('Cyclic Data Visualization using HSV Colormap')

# Zeige das Diagramm an
plt.show()

Matplotlib Regenbogen-Farben-Farbkarten-Visualisierung Beispiel. Bild von Autor.

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

# Generiere synthetische Höhenlinedaten
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  # Höhenlinedaten

# Plotte die Höhenlinedaten mit der 'plasma' Farbkarte
plt.contourf(X, Y, Z, cmap='plasma')

# Füge eine Farbleiste hinzu
plt.colorbar(label='Elevation (m)')

# Füge Titel und Beschriftungen hinzu
plt.title('Topographic Map (Plasma Colormap)')
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')

# Zeige das Diagramm an
plt.show()

Matplotlib perceptuell uniforme Farbverteilung Visualisierungsbeispiel. Bild vom Autor.

Erstellung und Änderung von Matplotlib-Farbbalken

Obwohl Matplotlib eine Vielzahl von integrierten Farbbalken bietet, gibt es Szenarien, in denen Sie Ihre Farben anpassen möchten. Die wichtigsten Werkzeuge zur Erstellung benutzerdefinierter Farbbalken in Matplotlib sind ListedColormap und LinearSegmentedColormap.

Erstellung eines benutzerdefinierten Farbbalkens mit ListedColormap

ListedColormap ermöglicht es Ihnen, einen Farbbalken aus einer Liste spezifischer Farben zu erstellen. Diese Methode ist nützlich, wenn spezifische Farben bestimmten Kategorien in kategorisierten Daten zugewiesen werden sollen.

from matplotlib.colors import ListedColormap

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

# benutzerdefinierte Farblackliste für die Farbpalette (z.B. Abstufungen von Blau, Grün, Rot und Violett)
custom_colors = ['#1f77b4', '#2ca02c', '#d62728', '#9467bd']

# Erstellen einer ListedColormap mit den benutzerdefinierten Farben
custom_cmap = ListedColormap(custom_colors)

# Größe des Diagramms festlegen
plt.figure(figsize=(8, 6))

# Erstellen eines Balkendiagramms mit der benutzerdefinierten Farbpalette
bars = plt.bar(categories, values, color=custom_cmap.colors)

# einen Titel hinzufügen
plt.title('Bar Chart with Custom ListedColormap')

# Achsen beschriften
plt.xlabel('Categories')
plt.ylabel('Values')

# das Diagramm anzeigen
plt.show()

Matplotlib benutzerdefinierte Farbpalette mit ListedColormap. Bild vom Autor.

Erstellen einer benutzerdefinierten Farbpalette mit LinearSegmentedColormap

LinearSegmentedColormap ermöglicht es Ihnen, Farbpaletten zu erstellen, die sanft zwischen Farben übergehen. Dies ist wert zu wissen, da kontinuierliche Daten oft gradientenartige Farbänderungen erfordern. Hier gebe ich auch die Anzahl der Intervalle an, die ich für meine Visualisierung möchte.

from matplotlib.colors import LinearSegmentedColormap

# Erstellen eines Wertegitters für eine 2D-Gauss-Funktion
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))

# Definition einer benutzerdefinierten Farbskala, die von Blau über Weiß zu Rot übergeht
colors = ['blue', 'white', 'red']
custom_cmap = LinearSegmentedColormap.from_list('blue_white_red', colors)

# Anpassung der Anzahl der Farbklassen (diskrete Ebenen)
# Angabe der Anzahl der Ebenen (z.B. 10 für 10 unterschiedliche Farbbereiche)
num_classes = 10
levels = np.linspace(Z.min(), Z.max(), num_classes)

# Einstellen der Abbildungsgröße
plt.figure(figsize=(8, 6))

# Darstellung der 2D-Gauss-Funktion mit der angepassten Farbskala
contour = plt.contourf(X, Y, Z, levels=levels, cmap=custom_cmap)

# Hinzufügen einer Farbleiste, um die diskreten Farbklassen anzuzeigen
plt.colorbar(contour, label='Gaussian Function Value')

# Hinzufügen von Achsenbeschriftungen
plt.xlabel('X')
plt.ylabel('Y')

# Hinzufügen einer Überschrift
plt.title(f'2D Gaussian with {num_classes} Discrete Color Classes')

# Anzeige des Diagramms
plt.show()

Matplotlib benutzerdefinierte Anpassung der Anzahl der Farbklassen. Bild vom Autor.

Anpassung des Farbbereichs und der Intensität

Vous können die Intensität oder den Farbtonbereich einer vorhandenen Farbbildkarte steuern, indem Sie deren Normalisierung manipulieren oder sie auf einen Teilsatz der verfügbaren Farben zuschneiden. Im folgenden Beispiel werden die Farb Bereiche zugeschnitten, um Temperaturen zwischen 16 und 40 Grad Celsius anzuzeigen.

# Richten Sie die Anzeige für die Heatmap ein
plt.figure(figsize=(12, 8))

# Definieren Sie eine benutzerdefinierte Normalisierung für den Temperaturbereich
norm = mcolors.Normalize(vmin=16, vmax=40)

# Erstellen Sie die Heatmap mit einer sequenzieller Farbbildkarte
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Fügen Sie eine Farbandleiste hinzu, um die Temperatur darzustellen
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Beschriften Sie die Achsen
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Setzen Sie die y-Ticks, um Monatnamen anstelle von Zahlen anzuzeigen
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Fügen Sie eine Überschrift zur Heatmap hinzu
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Zeigen Sie die Anzeige
plt.grid(False)
plt.show()

Matplotlib Anpassung von Farb Bereichen und Intensität. Bild vom Autor.

Kombinieren vorhandener Farbbildkarten

Man kann auch bestehende Farbbereiche durch Mischen mehrerer Farbbereiche kombinieren, um komplexere Visualisierungen zu erstellen.

from matplotlib.colors import LinearSegmentedColormap, Normalize

# Synthetische Höhendaten erstellen
x = np.linspace(-180, 180, 500)  # Längengrad
y = np.linspace(-90, 90, 250)    # Breitengrad
X, Y = np.meshgrid(x, y)
Z = 5000 * np.sin(np.sqrt(X**2 + Y**2) * np.pi / 180)  # Synthetische Höhendaten

# Basis-Farbbereiche definieren ('viridis' und 'cividis')
cmap1 = plt.get_cmap('viridis')
cmap2 = plt.get_cmap('cividis')

# Einen benutzerdefinierten Farbbereich durch Mischen der beiden Basis-Farbbereiche erstellen
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)

# Den gemischten Farbbereich erstellen
custom_cmap = blend_colormaps(cmap1, cmap2, blend_ratio=0.5)

# Die Daten für die Visualisierung normalisieren
norm = Normalize(vmin=-5000, vmax=5000)

# Die Größe des Diagramms festlegen
plt.figure(figsize=(12, 6))

# Die synthetischen Höhendaten mit dem gemischten Farbbereich plotten
contour = plt.contourf(X, Y, Z, levels=100, cmap=custom_cmap, norm=norm)

# Eine Farbleiste hinzufügen, um die gemischte Farbabstufung zu zeigen
plt.colorbar(contour, label='Elevation (meters)')

# Achsenbeschriftungen hinzufügen
plt.xlabel('Longitude')
plt.ylabel('Latitude')

# Eine Überschrift hinzufügen
plt.title('Geographical Elevation Data with Blended Colormap (Viridis + Cividis)')

# Das Diagramm anzeigen
plt.show()

Matplotlib Kombinieren bestehender Farbbereiche. Bild vom Autor.

Farbbereiche umkehren, indem man die Endung _r hinzufügt

Man kann jeden Farbbereich in Matplotlib umkehren, indem man die Endung _r an seinen Namen anhängt.

# Richten Sie die Zeichenfläche für die Heatmap ein
plt.figure(figsize=(12, 8))

# Erstellen Sie eine benutzerdefinierte Normalisierung für den Farbbereich
norm = mcolors.Normalize(vmin=16, vmax=40)

# Ploten Sie die Heatmap mit imshow und dem sequenziellen Farbbereich
im = plt.imshow(monthly_temperature_table, cmap='YlOrRd_r', norm=norm, aspect='equal')

# Fügen Sie eine Farbpalette mit horizontaler Ausrichtung hinzu
cbar = plt.colorbar(im, orientation='horizontal', pad=0.1)
cbar.set_label('Temperature (°C)', labelpad=10)

# Fügen Sie Achsenbeschriftungen hinzu
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Setzen Sie die y-Ticks, um Monatsnamen anstelle von Zahlen anzuzeigen
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Fügen Sie eine Überschrift hinzu
plt.title('Temperature Heatmap (Sequential Colormap)')

# Zeigen Sie das Diagramm an
plt.show()

Matplotlib Farbbereiche umkehren, indem man die Endung _r hinzufügt. Bild vom Autor.

Behandlung häufiger Fehler bei Matplotlib Farbbereichen

Bei der Arbeit mit Farbtabellen in Matplotlib können Sie auf Fehler stoßen, die Ihren Arbeitsablauf beeinflussen. Folgende Fehler und deren Fehlerbehebung werden hier vorgestellt.

AttributeError: module ‚matplotlib‘ has no attribute ‚colormaps’

Dieser Fehler tritt auf, wenn Sie Matplotlib-Versionen vor 3.4.0 verwenden, um matplotlib.colormaps zuzugreifen. Das colormaps-Attribut wurde in Matplotlib 3.4.0 eingeführt. Überprüfen Sie zuerst Ihre Matplotlib-Version mit dem folgenden Code, um diesen Fehler zu beheben.

import matplotlib
print(matplotlib.__version__)

Upgraden Sie mit dem folgenden pip-Befehl.

pip install --upgrade matplotlib

Falls Sie Probleme beim Upgraden Ihrer Matplotlib-Version haben, versuchen Sie die folgende Methode, um auf Farbtabellen zuzugreifen.

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

Fehlgeschlagene Farbzuweisungen

Sie könnten falsche Farbzuordnungen erleben, wenn Sie einen Wert außerhalb des erwarteten Bereichs übergeben oder wenn die Farbbildübersetzung falsch angewendet wird. Falsche Farbzuordnungen können auch auftreten, wenn die Farbbildübersetzung für kontinuierliche Daten gedacht ist, aber auf kategoriale Daten angewendet wird oder umgekehrt.

Um sicherzustellen, dass Ihre Daten im erwarteten Bereich liegen, normalisieren oder skalieren Sie diese stets mit den Parametern vmax und vmin.

import matplotlib.colors as mcolors

# Erstellen Sie einen Beispieltemperaturdatensatz
data = np.random.rand(10, 10) * 100  # Passen Sie den Bereich an, um Ihre Daten zu matchen

# Erstellen Sie eine Farbnormalisierungsinstanz, um die Daten auf den Bereich der Farbbildübersetzung zu skalieren
norm = mcolors.Normalize(vmin=0, vmax=100)

# Erstellen Sie ein Heatmap mit der 'viridis' Farbbildübersetzung und der angegebenen Normalisierung
plt.imshow(data, cmap='viridis', norm=norm, interpolation='nearest')
plt.colorbar()
plt.show()

Für eine feinere Kontrolle können Sie die Farbgrenzen explizit mit den Parametern boundaries oder norm in den Plotting-Funktionen definieren.

Visuelle Artefakte und unerwartete Ergebnisse

Bei der Arbeit mit diskreten oder niedriger Auflösung befindlichen Daten können Sie unerwünschte Farbbänder, übermäßigen Kontrast oder Farbab diffusion erleben. Das Problem tritt auf, wenn Ihre Daten einen begrenzten Bereich haben, aber mit einer kontinuierlichen Farbskala angezeigt werden.

Um dieses Problem zu lösen, verwenden Sie mehr Datenpunkte oder passen Sie die Anzahl der Farbpegel an, um die Übergänge zu glätten.

# Erhöhen Sie die Anzahl der Bins in der Farbskala
cmap = plt.get_cmap('viridis', 256)
plt.imshow(data, cmap=cmap)

Sie können die Farbskala in feste Ebenen aufteilen, um diskrete Daten dort zu handhaben, wo es angebracht ist.

cmap = plt.get_cmap('inferno', 10)  # Teilen Sie die Farbskala in 10 diskrete Ebenen auf
plt.imshow(data, cmap=cmap)

Sie können auch die Anzeigeeinstellungen überprüfen und die Auflösung insbesondere beim Speichern der Visualisierungen anpassen, um niedrig aufgelöste Diagramme zu vermeiden

plt.savefig('plot.png', dpi=300)  # Speichern Sie die Abbildung mit einer höheren Auflösung

Farbverzerrung aufgrund von Clipping

Farbstörungen treten auf, wenn die Daten extreme Werte außerhalb des erwarteten Farbbereichs enthalten. Dies führt dazu, dass Teile der Daten abgeschnitten und der minimale oder maximale Farbe in der Farbbildtabelle zugewiesen werden.

Um Farbstörungen zu vermeiden, passen Sie die Farbgrenzen mit vmin und vmax an, um den Bereich Ihrer Daten zu entsprechen und Abschneiden zu verhindern.

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

Sie sollten auch robuste Skalierung anwenden, um Ausreißer zu handhaben, indem Sie benutzerdefinierte Grenzen festlegen, die extreme Werte ausschließen.

import numpy as np
robust_vmin, robust_vmax = np.percentile(data, [2, 98])  # Verwenden Sie Perzentile, um extreme Ausreißer zu entfernen
plt.imshow(data, cmap='inferno', vmin=robust_vmin, vmax=robust_vmax)

Farbbildtabelle wird in 3D-Diagrammen nicht korrekt angezeigt

Wenn es ein Problem mit der Datenabbildung auf der 3D-Oberfläche gibt, können Farbbildtafeln in den 3D-Darstellungen möglicherweise nicht korrekt angezeigt werden. Um dies zu lösen, stellen Sie sicher, dass die z-Achsen-Daten normalisiert werden, um in den erwarteten Bereich der Farbbildtabelle zu passen. Verwenden Sie auch die geeigneten Farbbildtabelle-Grenzen, um den vollen Bereich der z-Werte zu erfassen.

from mpl_toolkits.mplot3d import Axes3D

# Generiere Beispieldata für ein 3D-Flächen Diagramm
X, Y = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = np.sin(np.sqrt(X**2 + Y**2))

# Erstelle ein 3D-Achsenobjekt
ax = plt.axes(projection='3d')

# Plotte die Oberfläche mit der 'viridis' Farbskala und passe die Farbgrenzen an
ax.plot_surface(X, Y, Z, cmap='viridis', vmin=np.min(Z), vmax=np.max(Z))
plt.show()

Schlussfolgerung

Die Wahl der richtigen Farbskala ist ein wichtiger Schritt, denn sie beeinflusst wirklich, wie Nutzer deine Daten wahrnehmen und verstehen. Meiner Meinung nach ist es ein großer Fehler, viel Zeit in die Datenanalyse zu investieren und dann in der letzten Phase, der Präsentation deiner Ergebnisse, schlampig zu sein.

Glücklicherweise bietet Matplotlib viele Optionen, um sicherzustellen, dass deine Visualisierungen eine überzeugende Geschichte erzählen. Melde dich für unseren Kurs an, Einführung in die Datenvisualisierung mit Matplotlib, um Experte zu werden. Und wenn du ein Python-Nutzer bist, der auch Seaborn für die Visualisierung verwendet (es ist großartig, beides zu kennen), lies unsere Schnellreferenz zur Farbwahl in Seaborn und vervollständige dies mit unserem Einführung in die Datenvisualisierung mit Seaborn Kurs.