Colormap Matplotlib : guide complet des cartes de couleurs en Python

Name

Soren Atelier

Updated on 12/02/2026

Choisir les bonnes couleurs pour une visualisation de données est trompeusement difficile. Prenez une colormap arc-en-ciel et votre heatmap paraît spectaculaire — mais la non-uniformité perceptuelle déforme les données, induit le public en erreur et échoue complètement pour toute personne ayant une déficience de vision des couleurs. Utilisez une palette à teinte unique et des motifs subtils disparaissent dans un mur de nuances presque identiques. La différence entre un graphique qui révèle un insight et un autre qui le masque se joue souvent sur une décision : la colormap.

Matplotlib est livré avec plus de 150 colormaps intégrées et une API flexible pour créer les vôtres. Le défi n’est pas le manque d’options — c’est de savoir quelle colormap utiliser, quand l’utiliser, et comment la personnaliser pour votre dataset. Un mauvais choix peut ruiner silencieusement la précision de votre visualisation ; le bon rend des données complexes immédiatement lisibles.

Ce guide couvre tous les aspects pratiques des colormaps Matplotlib : les quatre grandes catégories, les maps intégrées les plus importantes, comment les appliquer selon les types de graphiques, comment construire des colormaps personnalisées depuis zéro, et comment choisir une colormap à la fois scientifiquement fidèle et accessible.

Qu’est-ce qu’une colormap dans Matplotlib ?

Une colormap est une fonction de correspondance qui traduit des valeurs scalaires en couleurs. Étant donné un nombre (généralement normalisé dans l’intervalle 0–1), la colormap renvoie un tuple de couleur RGBA. Matplotlib représente les colormaps comme des objets héritant de matplotlib.colors.Colormap, et chaque fonction de tracé acceptant un paramètre cmap utilise ce système en interne.

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

Quand vous écrivez plt.imshow(data, cmap='viridis'), Matplotlib normalise vos données dans [0, 1] via un objet Normalize, puis passe chaque valeur normalisée dans la colormap pour produire les couleurs finales des pixels. Comprendre ce processus en deux étapes — normalisation, puis correspondance de couleurs — est la clé pour contrôler chaque aspect de la couleur dans vos graphiques.

Les quatre catégories de colormaps

Matplotlib organise ses colormaps en quatre catégories fonctionnelles. Chacune correspond à un type de données, et utiliser la mauvaise catégorie est l’erreur de colormap la plus fréquente.

Colormaps séquentielles

Les colormaps séquentielles varient de façon continue du clair au foncé (ou l’inverse) dans une seule teinte ou une plage étroite de teintes. Elles sont conçues pour des données ayant un ordre naturel de faible à élevé, sans point milieu particulier.

Quand les utiliser : relevés de température, densité de population, altitude, probabilité, toute variable continue avec une direction significative.

Exemples clés : 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()

Colormaps divergentes

Les colormaps divergentes utilisent deux teintes contrastées qui se rejoignent sur un point milieu neutre (souvent blanc ou gris clair). Elles mettent en évidence les écarts dans les deux directions par rapport à une valeur centrale.

Quand les utiliser : anomalies de température (au-dessus/en dessous de la moyenne), matrices de corrélation, profit/perte, toute donnée où zéro ou un point milieu a une signification particulière.

Exemples clés : 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()

Astuce : définissez toujours vmin et vmax de manière symétrique autour du point milieu afin que la couleur neutre s’aligne sur zéro (ou sur votre valeur centrale choisie).

Colormaps qualitatives

Les colormaps qualitatives fournissent un ensemble de couleurs visuellement distinctes, sans ordre implicite. Chaque couleur est autant que possible différente de ses voisines, ce qui les rend idéales pour des labels catégoriels.

Quand les utiliser : labels de clusters, scatter plots catégoriels, bar charts avec des groupes non ordonnés.

Exemples clés : 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()

Colormaps cycliques

Les colormaps cycliques commencent et finissent sur la même couleur, ce qui les rend adaptées aux données qui « bouclent » — angles, phases, heure de la journée, direction du vent.

Quand les utiliser : données de phase, directions de boussole, signaux périodiques, heures de la journée.

Exemples clés : 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()

Tableau comparatif : catégories de colormaps

Référence des colormaps intégrées

Matplotlib inclut des colormaps issues de plusieurs familles. Voici les plus utilisées, par catégorie.

Séquentielles uniformes perceptuellement

Ces colormaps ont été conçues pour que des pas égaux dans les données produisent des pas égaux en luminosité perçue. C’est la recommandation par défaut dans la plupart des cas d’usage.

Colormaps divergentes populaires

Utiliser des colormaps selon les types de graphiques

Heatmaps avec 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 avec encodage par la couleur

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

Graphiques de contours

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 pour des grilles irrégulières

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

Personnalisation de la colorbar

La colorbar est la légende de votre colormap. La personnaliser correctement est essentiel pour une visualisation lisible.

Options de base de la colorbar

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

Colorbar discrète avec BoundaryNorm

Quand vos données se répartissent naturellement en classes discrètes (niveaux de risque, catégories de notation), utilisez BoundaryNorm pour créer des frontières nettes entre couleurs au lieu d’un dégradé continu.

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

Colorbar horizontale

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

Créer des colormaps personnalisées

Quand les colormaps intégrées ne correspondent pas à vos besoins — couleurs de marque, conventions propres à un domaine, ou exigences perceptuelles spécifiques — Matplotlib fournit deux classes pour créer les vôtres.

ListedColormap : à partir d’une liste de couleurs

ListedColormap crée une colormap à partir d’une liste explicite de couleurs. Chaque couleur occupe une portion égale de l’intervalle [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 : dégradés lisses

LinearSegmentedColormap crée des transitions de couleur continues. L’approche la plus simple utilise from_list, qui interpole linéairement entre des couleurs d’ancrage.

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

Avancé : format dictionnaire de segments

Pour un contrôle total sur la transition de chaque canal de couleur, définissez un dictionnaire de segments. Chaque canal (rouge, vert, bleu) reçoit une liste de tuples (x, y_left, y_right) spécifiant les points d’ancrage.

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

Enregistrer une colormap personnalisée

Enregistrez votre colormap afin de pouvoir la référencer par son nom dans n’importe quelle fonction de tracé, comme une colormap intégrée :

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

Inverser une colormap

Ajoutez _r à n’importe quel nom de colormap pour obtenir sa version inversée. C’est utile quand vous voulez inverser l’accent visuel — par exemple, rendre les valeurs élevées plus sombres plutôt que plus claires.

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

Chaque colormap intégrée possède un équivalent inversé : plasma_r, coolwarm_r, RdBu_r, inferno_r, etc.

Tronquer et extraire des sous-ensembles de colormap

Parfois, vous n’avez besoin que d’une portion d’une colormap. Utilisez Colormap.__call__ avec np.linspace et ListedColormap pour extraire une tranche :

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

Normalisation : contrôler la façon dont les données se mappent aux couleurs

La normalisation détermine comment les valeurs brutes sont converties dans [0, 1] avant le passage dans la colormap. Le comportement par défaut est linéaire, mais Matplotlib propose plusieurs alternatives.

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

Choisir la bonne colormap pour vos données

Choisir la bonne colormap est une décision de design aux conséquences réelles. Voici un cadre pratique :

1. Les données sont-elles séquentielles (du faible vers l’élevé) ? Utilisez une colormap séquentielle. Commencez par viridis. Si vous avez besoin de plus de contraste, essayez plasma ou inferno.

2. Les données divergent-elles autour d’un centre significatif ? Utilisez une colormap divergente. coolwarm pour un rendu plus subtil, RdBu pour un contraste fort. Définissez vmin et vmax de manière symétrique.

3. Les données sont-elles catégorielles sans ordre ? Utilisez une colormap qualitative. tab10 jusqu’à 10 catégories, tab20 jusqu’à 20.

4. Les données « bouclent » (angles, phases) ? Utilisez une colormap cyclique. twilight est la meilleure option moderne.

5. Le public inclut-il des personnes avec déficience de vision des couleurs ? Utilisez cividis (séquentielle) ou viridis. Évitez les paires rouge-vert comme RdYlGn.

6. La figure sera-t-elle imprimée en niveaux de gris ? Utilisez viridis, plasma, inferno ou magma — elles conservent une luminance qui augmente de manière monotone.

Accessibilité : colormaps compatibles daltonisme

Environ 8 % des hommes et 0,5 % des femmes présentent une forme de déficience de vision des couleurs, le plus souvent liée à la difficulté à distinguer le rouge du vert. Les colormaps uniformes perceptuellement (viridis, plasma, inferno, magma, cividis) ont été conçues spécifiquement pour rester lisibles sous les formes les plus courantes de daltonisme.

Colormaps à éviter pour l’accessibilité : jet, rainbow, RdYlGn, RdYlBu (quand la distinction rouge-vert est critique), hot.

Pourquoi jet est nuisible : la colormap jet (un arc-en-ciel du bleu vers le cyan, vert, jaune, puis rouge) présente des non-uniformités perceptuelles qui créent de fausses frontières dans les données. Des zones très différentes en valeur réelle peuvent sembler similaires, tandis que de faibles différences autour du cyan-vert peuvent paraître dramatiques. Elle échoue aussi totalement pour les personnes ayant une deutéranopie (daltonisme rouge-vert).

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

Lister toutes les colormaps disponibles

Pour voir toutes les colormaps disponibles dans votre version de Matplotlib :

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)}")

Pour les afficher visuellement :

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

Visualisation interactive avec PyGWalker

Lorsqu’on explore des datasets de manière interactive, configurer manuellement des colormaps pour chaque graphique peut vous ralentir. PyGWalker (opens in a new tab) est une bibliothèque Python open-source qui transforme n’importe quel DataFrame pandas ou polars en une interface interactive style Tableau directement dans Jupyter. Vous pouvez glisser-déposer des variables sur les axes, assigner des encodages couleur et changer de type de visualisation — sans écrire de code de colormap ou de tracé à la main.

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)

C’est particulièrement utile en analyse exploratoire quand vous décidez encore quelles variables visualiser et quels encodages de couleur rendent les motifs les plus clairs. Une fois la bonne visualisation trouvée, vous pouvez toujours la reproduire dans Matplotlib avec une configuration de colormap précise.

Pièges courants et comment les éviter

FAQ

Qu’est-ce qu’une colormap dans Matplotlib ?

Une colormap dans Matplotlib est une fonction qui associe des valeurs numériques scalaires à des couleurs. Elle prend une valeur entre 0 et 1 et renvoie un tuple RGBA. Les colormaps sont utilisées dans des fonctions comme imshow, scatter, contourf et pcolormesh pour visualiser des données avec des dégradés de couleur. On y accède via plt.colormaps['name'] ou en passant le nom au paramètre cmap.

Comment choisir la bonne colormap pour mes données ?

Pour des données séquentielles (du faible vers l’élevé), utilisez viridis, plasma ou inferno. Pour des données divergentes (écart par rapport à un centre), utilisez coolwarm ou RdBu. Pour des données catégorielles, utilisez tab10 ou Set1. Pour des données cycliques comme des angles, utilisez twilight. Pensez toujours à l’accessibilité — viridis et cividis sont sûres pour les personnes daltoniennes.

Comment créer une colormap personnalisée dans Matplotlib ?

Utilisez matplotlib.colors.ListedColormap pour créer une colormap à partir d’une liste de couleurs spécifiques, ou matplotlib.colors.LinearSegmentedColormap.from_list('name', colors) pour créer un dégradé lisse entre des couleurs d’ancrage. Enregistrez-la avec plt.colormaps.register() pour pouvoir l’utiliser par son nom.

Comment inverser une colormap dans Matplotlib ?

Ajoutez _r à n’importe quel nom de colormap. Par exemple, cmap='viridis_r' donne la version inversée de viridis. Cela fonctionne pour toutes les colormaps intégrées. Pour les colormaps personnalisées, appelez la méthode .reversed() sur l’objet colormap.

Pourquoi éviter la colormap jet ?

La colormap jet présente des non-uniformités perceptuelles qui créent de fausses frontières et masquent de vrais motifs dans les données. Elle échoue aussi pour les personnes ayant un daltonisme rouge-vert. Matplotlib a changé sa colormap par défaut de jet à viridis dans la version 2.0 précisément à cause de ces problèmes. Utilisez plutôt viridis, plasma ou cividis.

Comment ajouter une colorbar à un graphique Matplotlib ?

Appelez plt.colorbar(mappable) où mappable est l’objet renvoyé par imshow, scatter, contourf ou des fonctions similaires. Personnalisez-la avec des paramètres comme label, orientation ('horizontal' ou 'vertical'), shrink et pad. Vous pouvez aussi accéder aux axes de la colorbar via cbar.ax pour un contrôle plus fin.

Conclusion

Les colormaps ne sont pas des choix décoratifs — ce sont des composants fonctionnels qui déterminent si votre visualisation communique fidèlement ou induit en erreur. Matplotlib vous offre une large bibliothèque de colormaps intégrées, organisées en quatre catégories claires (séquentielles, divergentes, qualitatives, cycliques), ainsi que les outils nécessaires pour en créer de entièrement personnalisées. La famille uniforme perceptuellement (viridis, plasma, inferno, magma, cividis) devrait être votre point de départ par défaut pour toute donnée séquentielle. Pour des données divergentes, choisissez une map comme coolwarm ou RdBu et centrez toujours la couleur neutre sur le point milieu pertinent de vos données. Pour des catégories, privilégiez tab10 ou Set1. Et gardez toujours votre audience à l’esprit — utiliser des colormaps compatibles daltonisme n’est pas optionnel, c’est une pratique professionnelle.