5 formas comunes de usar los colormaps (cmaps) de Matplotlib

Name

Elwynn AI

Updated on 15/11/2025

El sistema de colormaps (cmap) de Matplotlib es mucho más rico que “simplemente elegir una paleta de colores”. Una vez que entiendes la API, puedes:

• Visualizar valores continuos (heatmaps, imágenes)
• Codificar dimensiones extra en gráficos de dispersión
• Crear colormaps discretos para categorías
• Usar escalados no lineales (log, límites) para datos complicados
• Muestrear colores de un colormap para dar estilo a tus propios gráficos

En esta publicación veremos 5 patrones comunes con código + salidas de gráficos reales. Puedes copiar y pegar cada fragmento en tu propio notebook o script.

Todos los ejemplos asumen:

import numpy as np
import matplotlib.pyplot as plt

1. Colormap continuo con imshow

El uso más básico de los colormaps es visualizar arreglos 2D con imshow, por ejemplo: heatmaps, imágenes o cualquier malla regular.

Código

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

Gráfico

Obtienes un heatmap suave usando el colormap perceptualmente uniforme viridis:

(Esto corresponde a la primera imagen de arriba: un heatmap morado–verde con barra de color.)

Puntos clave:

• cmap="viridis" selecciona el colormap.
• plt.colorbar() dibuja una escala de color para que el lector pueda interpretar los valores.
• Cualquier arreglo 2D de NumPy se puede pasar a imshow.

2. Gráfico de dispersión con colormap y colorbar

Puedes usar colormaps para codificar una dimensión numérica adicional en un gráfico de dispersión (por ejemplo: tiempo, intensidad, probabilidad).

Código

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

Gráfico

Obtienes un gráfico de dispersión donde los colores de los puntos cambian suavemente siguiendo el colormap plasma, además de una barra de color que explica qué significan los colores.

Puntos clave:

• c=values proporciona los datos numéricos que se mapean a colores.
• cmap="plasma" elige el colormap.
• Pasa el objeto scatter a plt.colorbar() para obtener una barra de color coherente.

3. Colormap discreto para categorías

Los colormaps son continuos por defecto, pero también puedes usarlos para crear un conjunto pequeño de colores discretos para categorías (resultados de clasificación, etiquetas, etc.).

Código

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

Gráfico

Verás un gráfico de dispersión donde cada categoría (0–3) tiene su propio color distintivo (tomado de tab10).

Puntos clave:

• ListedColormap te permite construir un colormap a partir de una lista de colores.
• Es ideal cuando necesitas un número pequeño de colores estables para categorías.
• Usamos tab10 (un buen colormap cualitativo por defecto) y tomamos 4 colores de él.

4. Uso de normalización (LogNorm) con un colormap

A veces los datos abarcan varios órdenes de magnitud. Mapearlos linealmente a colores puede ocultar estructura. En su lugar, combina un colormap con una función de normalización como LogNorm.

Código

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

Gráfico

Verás un campo coloreado 2D en el que las zonas con valores pequeños y grandes son visibles, gracias al escalado logarítmico, usando magma.

Puntos clave:

• norm=LogNorm() controla cómo se mapean los valores al rango [0, 1] antes de aplicar cmap.
• Funciona con pcolormesh, imshow, scatter, etc.
• Otras normas: Normalize, BoundaryNorm, PowerNorm, etc.

5. Muestrear colores de un colormap para gráficos de líneas

Los colormaps no son solo para gráficos “rellenos”. Puedes muestrear colores individuales de un colormap y usarlos donde quieras: líneas, barras, anotaciones, etc.

Código

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

Gráfico

Obtendrás múltiples ondas seno, cada una con un color diferente tomado de cividis, variando suavemente a lo largo del colormap.

Puntos clave:

• plt.cm.<name> te da un objeto colormap que puedes llamar como una función.
• cmap(t) devuelve un color RGBA para t en [0, 1].
• Es una forma práctica de obtener paletas de color coherentes y estéticamente agradables.

Conclusión

Estos 5 patrones cubren gran parte del uso cotidiano de los colormaps de Matplotlib:

1. Heatmaps continuos con imshow + cmap.
2. Gráficos de dispersión donde el color codifica una dimensión de valor extra.
3. Colores categóricos discretos usando ListedColormap.
4. Escalado no lineal con LogNorm (y similares) + colormaps.
5. Muestreo de colores de un colormap para estilos personalizados (líneas, barras, etc.).

Una vez que te sientas cómodo con esto, puedes explorar:

• Colormaps personalizados (a partir de tus propias listas de colores o herramientas externas)
• BoundaryNorm para rangos de valores discretos (p. ej. bins)
• Colormaps perceptualmente uniformes (viridis, plasma, cividis, etc.) para mejor legibilidad y accesibilidad