Skip to content

5 façons courantes d’utiliser les colormaps (cmaps) de Matplotlib

Elwynn AI
Name
Elwynn AI

Updated on

5 exemples prêts à l’emploi de matplilib cmaps/colormaps, que vous pouvez étudier ou copier directement pour les modifier.

Le système de colormap (cmap) de Matplotlib va bien au‑delà de « choisir un jeu de couleurs ». Une fois que vous comprenez l’API, vous pouvez :

  • Visualiser des valeurs continues (heatmaps, images)
  • Encoder des dimensions supplémentaires dans des nuages de points
  • Créer des colormaps discrètes pour des catégories
  • Utiliser des mises à l’échelle non linéaires (log, bornes) pour des données difficiles
  • Échantillonner des couleurs dans une colormap pour styliser vos propres graphiques

Dans cet article, nous allons parcourir 5 schémas d’utilisation courants avec code + rendus réels de graphiques. Vous pouvez copier–coller chaque extrait dans votre propre notebook ou script.

Tous les exemples supposent :

import numpy as np
import matplotlib.pyplot as plt

1. Colormap continue avec imshow

L’usage le plus basique des colormaps consiste à visualiser des tableaux 2D avec imshow — par exemple des heatmaps, des images ou toute grille régulière.

matplotlib-viridis-heatmap

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()

Graphique

Vous obtenez une heatmap lisse en utilisant la colormap perceptuellement uniforme viridis :

(Cela correspond à la première image ci‑dessus : une heatmap violet–vert avec une barre de couleurs.)

Points clés :

  • cmap="viridis" sélectionne la colormap.
  • plt.colorbar() trace une échelle de couleurs pour que le lecteur puisse interpréter les valeurs.
  • N’importe quel tableau NumPy 2D peut être passé à imshow.

2. Nuage de points avec colormap et colorbar

Vous pouvez utiliser des colormaps pour encoder une dimension numérique supplémentaire dans un nuage de points (par exemple temps, intensité, probabilité).

Scatter plot with colormap and colorbar

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()

Graphique

Vous obtenez un nuage de points dont les couleurs des points évoluent progressivement le long de la colormap plasma, ainsi qu’une colorbar qui explique la signification des couleurs.

Points clés :

  • c=values fournit les données numériques à mapper en couleurs.
  • cmap="plasma" choisit la colormap.
  • Passez l’objet scatter à plt.colorbar() pour obtenir une colorbar correspondante.

3. Colormap discrète pour des catégories

Les colormaps sont continues par défaut, mais vous pouvez aussi les utiliser pour créer un petit ensemble de couleurs discrètes pour des catégories (résultats de classification, labels, etc.).

Discrete colormap for categories

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()

Graphique

Vous verrez un nuage de points où chaque catégorie (0–3) possède sa propre couleur distincte (issue de tab10).

Points clés :

  • ListedColormap permet de construire une colormap à partir d’une liste de couleurs.
  • C’est idéal quand vous avez besoin d’un petit nombre de couleurs stables pour des catégories.
  • Nous avons utilisé tab10 (une bonne colormap qualitative par défaut) et en avons extrait 4 couleurs.

4. Utiliser une normalisation (LogNorm) avec une colormap

Parfois, les données couvrent plusieurs ordres de grandeur. Les mapper linéairement vers les couleurs peut masquer la structure. À la place, combinez une colormap avec une fonction de normalisation comme LogNorm.

ogNorm colormap

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()

Graphique

Vous verrez un champ 2D coloré où les zones de petites et de grandes valeurs restent toutes deux visibles grâce à la mise à l’échelle logarithmique, en utilisant magma.

Points clés :

  • norm=LogNorm() contrôle la façon dont les valeurs sont mappées dans l’intervalle [0, 1] avant d’appliquer cmap.
  • Fonctionne avec pcolormesh, imshow, scatter, etc.
  • Autres normalisations : Normalize, BoundaryNorm, PowerNorm, etc.

5. Échantillonner des couleurs depuis une colormap pour des courbes

Les colormaps ne servent pas uniquement aux graphiques « remplis ». Vous pouvez échantillonner des couleurs individuelles dans une colormap et les utiliser où vous voulez : courbes, barres, annotations, etc.

Sampling colors from a colormap for line plots

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()

Graphique

Vous obtiendrez plusieurs sinusoïdes, chacune avec une couleur différente tirée de cividis, variant progressivement le long de la colormap.

Points clés :

  • plt.cm.<name> vous donne un objet colormap que vous pouvez appeler comme une fonction.
  • cmap(t) renvoie une couleur RGBA pour t dans [0, 1].
  • C’est un moyen pratique d’obtenir des palettes de couleurs cohérentes et esthétiques.

Conclusion

Ces 5 schémas couvrent une grande partie des usages quotidiens des colormaps dans Matplotlib :

  1. Heatmaps continues avec imshow + cmap.
  2. Nuages de points où la couleur encode une dimension de valeur supplémentaire.
  3. Couleurs catégorielles discrètes avec ListedColormap.
  4. Mise à l’échelle non linéaire avec LogNorm (et consorts) + colormaps.
  5. Échantillonnage de couleurs depuis une colormap pour un style personnalisé (courbes, barres, etc.).

Une fois à l’aise avec ces approches, vous pouvez explorer :

  • Les colormaps personnalisées (à partir de vos propres listes de couleurs ou d’outils externes)
  • BoundaryNorm pour des plages de valeurs discrètes (par ex. des bins)
  • Les colormaps perceptuellement uniformes (viridis, plasma, cividis, etc.) pour une meilleure lisibilité et accessibilité