Mapa de colores de Matplotlib: guía completa de colormaps en Python

Name

Soren Atelier

Updated on 12/2/2026

Elegir los colores adecuados para una visualización de datos es engañosamente difícil. Elige un colormap arcoíris y tu heatmap se ve dramático, pero la no uniformidad perceptual distorsiona los datos, engaña a quien lo ve y falla por completo para cualquiera con deficiencia en la visión del color. Usa una paleta de un solo tono y los patrones sutiles desaparecen en una pared de matices casi idénticos. La diferencia entre un gráfico que revela insights y otro que los oculta a menudo se reduce a una decisión: el colormap.

Matplotlib incluye más de 150 colormaps integrados y una API flexible para crear los tuyos. El reto no es la falta de opciones, sino saber qué colormap usar, cuándo usarlo y cómo personalizarlo para tu dataset específico. Una mala elección puede arruinar silenciosamente la precisión de tu visualización; la correcta hace que datos complejos sean legibles de inmediato.

Esta guía cubre todos los aspectos prácticos de los colormaps en Matplotlib: las cuatro categorías principales, los mapas integrados más importantes, cómo aplicarlos en distintos tipos de gráficos, cómo construir colormaps personalizados desde cero y cómo elegir un colormap que sea científicamente preciso y accesible.

¿Qué es un colormap en Matplotlib?

Un colormap es una función de mapeo que traduce valores escalares de datos en colores. Dado un número (normalmente normalizado al rango 0--1), el colormap devuelve una tupla de color RGBA. Matplotlib representa los colormaps como objetos que heredan de matplotlib.colors.Colormap, y toda función de trazado que acepta un parámetro cmap usa este sistema internamente.

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

Cuando escribes plt.imshow(data, cmap='viridis'), Matplotlib normaliza tus datos a [0, 1] usando un objeto Normalize y luego pasa cada valor normalizado por el colormap para producir los colores finales de los píxeles. Entender este proceso de dos pasos —normalización y luego búsqueda de color— es la clave para controlar cada aspecto del color en tus gráficos.

Las cuatro categorías de colormaps

Matplotlib organiza sus colormaps en cuatro categorías funcionales. Cada una sirve para un tipo distinto de datos, y usar la categoría incorrecta es el error de colormap más común.

Colormaps secuenciales

Los colormaps secuenciales varían suavemente de claro a oscuro (o de oscuro a claro) en un solo tono o en un rango estrecho de tonos. Están diseñados para datos que tienen un orden natural de menor a mayor sin un punto medio especial.

Cuándo usarlo: Lecturas de temperatura, densidad de población, elevación, probabilidad, cualquier variable continua con una dirección significativa.

Ejemplos clave: 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

Los colormaps divergentes usan dos tonos contrastantes que se encuentran en un punto medio neutral (normalmente blanco o gris claro). Destacan la desviación en ambas direcciones respecto a un valor central.

Cuándo usarlo: Anomalías de temperatura (por encima/por debajo del promedio), matrices de correlación, ganancia/pérdida, cualquier dato donde cero o un punto medio tenga un significado especial.

Ejemplos clave: 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()

Consejo: Establece siempre vmin y vmax de forma simétrica alrededor del punto medio para que el color neutral se alinee con cero (o con tu valor central elegido).

Colormaps cualitativos

Los colormaps cualitativos proporcionan un conjunto de colores visualmente distintos sin un orden implícito. Cada color es lo más diferente posible de sus vecinos, lo que los hace ideales para etiquetas categóricas.

Cuándo usarlo: Etiquetas de clusters, scatter plots categóricos, gráficos de barras con grupos sin orden.

Ejemplos clave: 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 cíclicos

Los colormaps cíclicos empiezan y terminan en el mismo color, lo que los hace apropiados para datos que “envuelven” —ángulos, fases, hora del día, dirección del viento.

Cuándo usarlo: Datos de fase, direcciones de brújula, señales periódicas, horas del día.

Ejemplos clave: 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()

Tabla comparativa: categorías de colormaps

Referencia de colormaps integrados

Matplotlib incluye colormaps de varias familias. Estos son los más usados por categoría.

Secuenciales perceptualmente uniformes

Estos colormaps fueron diseñados para que pasos iguales en los datos produzcan pasos iguales en brillo percibido. Son la recomendación por defecto para la mayoría de casos.

Colormaps divergentes populares

Uso de colormaps en distintos tipos de gráficos

Heatmaps con 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 con codificación por color

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

Gráficos de contorno

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 para rejillas irregulares

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

Personalización de la colorbar

La colorbar es la leyenda de tu colormap. Personalizarla correctamente es esencial para una visualización legible.

Opciones básicas 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 discreta con BoundaryNorm

Cuando tus datos caen de forma natural en bins discretos (niveles de riesgo, categorías de calificación), usa BoundaryNorm para crear límites de color nítidos en lugar de un degradado suave.

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 horizontal

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

Creación de colormaps personalizados

Cuando los colormaps integrados no se ajustan a tus necesidades —colores corporativos, convenciones específicas de un dominio o requisitos perceptuales concretos— Matplotlib ofrece dos clases para crear los tuyos.

ListedColormap: a partir de una lista de colores

ListedColormap crea un colormap a partir de una lista explícita de colores. Cada color ocupa una porción igual del rango [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: degradados suaves

LinearSegmentedColormap crea transiciones suaves entre colores. El enfoque más simple usa from_list, que interpola linealmente entre colores ancla.

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

Avanzado: formato de diccionario de segmentos

Para tener control total sobre cómo transiciona cada canal de color, define un diccionario de segmentos. Cada canal (rojo, verde, azul) recibe una lista de tuplas (x, y_left, y_right) que especifican puntos ancla.

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

Registrar un colormap personalizado

Registra tu colormap para poder referenciarlo por nombre en cualquier función de trazado, igual que uno integrado:

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

Invertir un colormap

Añade _r al nombre de cualquier colormap para obtener su versión invertida. Esto es útil cuando quieres invertir el énfasis visual —por ejemplo, hacer que los valores altos sean más oscuros en lugar de más claros.

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

Cada colormap integrado tiene su contraparte invertida: plasma_r, coolwarm_r, RdBu_r, inferno_r, etc.

Truncar y extraer subconjuntos de un colormap

A veces solo necesitas una parte de un colormap. Usa Colormap.__call__ con np.linspace y ListedColormap para extraer un “slice”:

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

Normalización: controlar cómo los datos se mapean a colores

La normalización determina cómo los valores brutos de datos se convierten al rango [0, 1] antes de consultar el colormap. El valor por defecto es lineal, pero Matplotlib ofrece varias alternativas.

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

Elegir el colormap adecuado para tus datos

Elegir el colormap correcto es una decisión de diseño con consecuencias reales. Aquí tienes un marco práctico de decisión:

1. ¿Los datos son secuenciales (de menor a mayor)? Usa un colormap secuencial. Empieza con viridis. Si necesitas más contraste, prueba plasma o inferno.

2. ¿Los datos divergen desde un centro significativo? Usa un colormap divergente. coolwarm para un aspecto sutil, RdBu para contraste fuerte. Ajusta vmin y vmax simétricamente.

3. ¿Los datos son categóricos y no tienen orden? Usa un colormap cualitativo. tab10 para hasta 10 categorías, tab20 para hasta 20.

4. ¿Los datos “envuelven” (ángulos, fases)? Usa un colormap cíclico. twilight es la mejor opción moderna.

5. ¿La audiencia incluye personas con deficiencia en visión del color? Usa cividis (secuencial) o viridis. Evita pares rojo-verde como RdYlGn.

6. ¿La figura se imprimirá en escala de grises? Usa viridis, plasma, inferno o magma —mantienen una luminosidad que aumenta de forma monótona.

Accesibilidad: colormaps aptos para daltonismo

Aproximadamente el 8% de los hombres y el 0.5% de las mujeres tienen alguna forma de deficiencia en la visión del color, afectando con mayor frecuencia la capacidad de distinguir rojo de verde. Los colormaps perceptualmente uniformes (viridis, plasma, inferno, magma, cividis) fueron diseñados específicamente para seguir siendo legibles bajo las formas más comunes de daltonismo.

Colormaps a evitar por accesibilidad: jet, rainbow, RdYlGn, RdYlBu (cuando la distinción rojo-verde es crítica), hot.

Por qué jet es perjudicial: El colormap jet (un arcoíris de azul pasando por cian, verde, amarillo hasta rojo) tiene no uniformidades perceptuales que crean fronteras falsas en los datos. Regiones que difieren mucho en valor real pueden verse similares, mientras que pequeñas diferencias cerca del cian-verde pueden parecer dramáticas. Además, falla por completo para personas con deuteranopia (daltonismo rojo-verde).

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

Listar todos los colormaps disponibles

Para ver todos los colormaps disponibles en tu versión 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)}")

Para mostrarlos visualmente:

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

Visualización interactiva con PyGWalker

Al explorar datasets de forma interactiva, configurar manualmente colormaps para cada gráfico puede ralentizarte. PyGWalker (opens in a new tab) es una librería open-source de Python que convierte cualquier DataFrame de pandas o polars en una interfaz interactiva estilo Tableau directamente dentro de Jupyter. Puedes arrastrar variables a los ejes, asignar codificaciones de color y cambiar tipos de visualización, todo sin escribir a mano código de colormaps ni de plotting.

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)

Esto es especialmente útil durante el análisis exploratorio, cuando todavía estás decidiendo qué variables visualizar y qué codificaciones de color hacen más claros los patrones. Una vez que encuentras la visualización correcta, siempre puedes reproducirla en Matplotlib con una configuración de colormap precisa.

Errores comunes y cómo evitarlos

Preguntas frecuentes (FAQ)

What is a colormap in Matplotlib?

Un colormap en Matplotlib es una función que mapea valores numéricos escalares a colores. Toma un valor entre 0 y 1 y devuelve una tupla de color RGBA. Los colormaps se usan en funciones como imshow, scatter, contourf y pcolormesh para visualizar datos con gradientes de color. Accede a ellos con plt.colormaps['name'] o pasa el nombre como string al parámetro cmap.

How do I choose the right colormap for my data?

Para datos secuenciales (de menor a mayor), usa viridis, plasma o inferno. Para datos divergentes (desviación respecto a un centro), usa coolwarm o RdBu. Para datos categóricos, usa tab10 o Set1. Para datos cíclicos como ángulos, usa twilight. Considera siempre la accesibilidad: viridis y cividis son seguros para personas con daltonismo.

How do I create a custom colormap in Matplotlib?

Usa matplotlib.colors.ListedColormap para crear un colormap a partir de una lista de colores específicos, o usa matplotlib.colors.LinearSegmentedColormap.from_list('name', colors) para crear un degradado suave entre colores ancla. Regístralo con plt.colormaps.register() para poder usarlo por nombre.

How do I reverse a colormap in Matplotlib?

Añade _r al nombre de cualquier colormap. Por ejemplo, cmap='viridis_r' da la versión invertida de viridis. Esto funciona para todos los colormaps integrados. Para colormaps personalizados, llama al método .reversed() del objeto colormap.

Why should I avoid the jet colormap?

El colormap jet tiene no uniformidades perceptuales que crean fronteras falsas y ocultan patrones reales en los datos. También falla para personas con daltonismo rojo-verde. Matplotlib cambió su default de jet a viridis en la versión 2.0 precisamente por estos problemas. Usa viridis, plasma o cividis en su lugar.

How do I add a colorbar to a Matplotlib plot?

Llama a plt.colorbar(mappable), donde mappable es el objeto devuelto por imshow, scatter, contourf u otras funciones similares. Personalízala con parámetros como label, orientation ('horizontal' o 'vertical'), shrink y pad. También puedes acceder a los ejes de la colorbar con cbar.ax para control detallado.

Conclusión

Los colormaps no son elecciones decorativas: son componentes funcionales que determinan si tu visualización comunica la verdad o engaña. Matplotlib te ofrece una gran biblioteca de colormaps integrados organizados en cuatro categorías claras (secuenciales, divergentes, cualitativos, cíclicos), junto con herramientas para construir otros completamente personalizados cuando lo necesites. La familia perceptualmente uniforme (viridis, plasma, inferno, magma, cividis) debería ser tu punto de partida por defecto para cualquier dato secuencial. Para datos divergentes, elige un mapa como coolwarm o RdBu y centra siempre el color neutral en el punto medio significativo de tus datos. Para categorías, recurre a tab10 o Set1. Y considera siempre a tu audiencia: usar colormaps aptos para daltónicos no es opcional, es una práctica profesional.