Paletas de colores en Seaborn

Tipos de paletas de color

La elección de la paleta correcta no es solo estética: comunica información. Una paleta mal elegida puede inducir a interpretaciones incorrectas o dificultar la lectura del gráfico.

Seaborn organiza las paletas en tres categorías según el tipo de dato que representan:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

sns.set_theme(style="whitegrid")

Paletas cualitativas

Las paletas cualitativas se usan cuando hue representa una variable categórica sin orden (países, especies, géneros). Los colores deben ser claramente distinguibles entre sí pero sin implicar un orden o gradiente.

paletas_cualitativas = [
    "deep", "muted", "pastel", "bright", "dark", "colorblind",
    "Set1", "Set2", "Set3", "tab10", "tab20"
]

fig, axes = plt.subplots(len(paletas_cualitativas), 1, figsize=(10, 12))

for ax, nombre in zip(axes, paletas_cualitativas):
    palette = sns.color_palette(nombre, 8)
    sns.palplot(palette, ax=ax)
    ax.set_title(f"'{nombre}'", fontsize=10, loc="left")
    ax.set_xticks([])
    ax.set_yticks([])

plt.suptitle("Paletas cualitativas de Seaborn", fontsize=14, fontweight="bold", y=1.01)
plt.tight_layout()
plt.show()

Las paletas de Seaborn (deep, muted, pastel, bright, dark, colorblind) son versiones optimizadas de las paletas Matplotlib, con mejor balance visual. colorblind es accesible para personas con daltonismo.

Paletas secuenciales

Las paletas secuenciales se usan cuando hue o los colores del mapa representan una variable numérica con un solo extremo (valores de 0 a máximo). Los colores van de claro (valores bajos) a oscuro (valores altos) o viceversa.

paletas_secuenciales = [
    "Blues", "Reds", "Greens", "Oranges", "Purples",
    "viridis", "plasma", "inferno", "magma", "cividis",
    "rocket", "mako", "flare", "crest",
    "YlOrRd", "YlGnBu", "BuPu"
]

fig, axes = plt.subplots(len(paletas_secuenciales), 1, figsize=(10, 18))

for ax, nombre in zip(axes, paletas_secuenciales):
    palette = sns.color_palette(nombre, 10)
    sns.palplot(palette, ax=ax)
    ax.set_title(f"'{nombre}'", fontsize=10, loc="left")
    ax.set_xticks([])
    ax.set_yticks([])

plt.suptitle("Paletas secuenciales (selección)", fontsize=14, y=1.01)
plt.tight_layout()
plt.show()

viridis, plasma, inferno y magma son paletas perceptualmente uniformes: cada paso en el valor numérico corresponde al mismo cambio visual percibido, lo que las hace más precisas que paletas tradicionales como jet.

Paletas divergentes

Las paletas divergentes se usan cuando los datos tienen un punto central significativo (típicamente 0) y se quiere mostrar tanto los valores positivos como negativos con colores diferentes. Son ideales para matrices de correlación, diferencias y cambios.

paletas_divergentes = [
    "coolwarm", "bwr", "seismic",
    "RdBu", "PuOr", "BrBG", "PRGn", "PiYG",
    "vlag", "icefire", "Spectral"
]

fig, axes = plt.subplots(len(paletas_divergentes), 1, figsize=(10, 12))

for ax, nombre in zip(axes, paletas_divergentes):
    palette = sns.color_palette(nombre, 11)
    sns.palplot(palette, ax=ax)
    ax.set_title(f"'{nombre}'", fontsize=10, loc="left")
    ax.set_xticks([])
    ax.set_yticks([])

plt.suptitle("Paletas divergentes (selección)", fontsize=14, y=1.01)
plt.tight_layout()
plt.show()

color_palette(): crear y reutilizar paletas

sns.color_palette() es la función principal para crear objetos de paleta. Devuelve una lista de colores RGB que se puede asignar a variables:

# Obtener una paleta como lista de colores
palette_deep = sns.color_palette("deep", 6)
print(type(palette_deep))
print(palette_deep[:3])  # primeros 3 colores como tuplas RGB

# Visualizar
plt.figure(figsize=(8, 1.5))
sns.palplot(palette_deep)
plt.title("Paleta 'deep' con 6 colores")
plt.show()

# Paleta desde lista de colores hex o nombres CSS
palette_custom = sns.color_palette(["#2ecc71", "#3498db", "#e74c3c", "#f39c12"])
plt.figure(figsize=(6, 1))
sns.palplot(palette_custom)
plt.title("Paleta personalizada con colores hex")
plt.show()

diverging_palette(): paletas divergentes personalizadas

# Crear paleta divergente con tonos personalizados
# Los valores son ángulos en el espacio de color HLS (0-360)
cmap_custom = sns.diverging_palette(
    h_neg=220,   # tono para valores negativos (azul)
    h_pos=20,    # tono para valores positivos (rojo-naranja)
    s=80,        # saturación
    l=55,        # luminosidad
    n=11,        # número de colores
    as_cmap=True # devolver como colormap de Matplotlib
)

# Ejemplo en un heatmap
penguins = sns.load_dataset("penguins")
corr = penguins.select_dtypes("number").corr()

import numpy as np
mask = np.triu(np.ones_like(corr, dtype=bool))

plt.figure(figsize=(8, 6))
sns.heatmap(corr, mask=mask, cmap=cmap_custom, vmin=-1, vmax=1,
            center=0, annot=True, fmt=".2f", square=True)
plt.title("Correlaciones con paleta divergente personalizada")
plt.tight_layout()
plt.show()

set_palette() y gestores de contexto

tips = sns.load_dataset("tips")

# Aplicar paleta globalmente
sns.set_palette("colorblind")

sns.boxplot(data=tips, x="day", y="total_bill", hue="sex",
            order=["Thur", "Fri", "Sat", "Sun"])
plt.title("Paleta global 'colorblind'")
plt.show()

# Paleta temporal con gestor de contexto
with sns.color_palette("Spectral", 4):
    sns.barplot(data=tips, x="day", y="tip",
                order=["Thur", "Fri", "Sat", "Sun"])
    plt.title("Paleta temporal 'Spectral'")
    plt.show()

# Fuera del bloque vuelve a la paleta global
sns.violinplot(data=tips, x="day", y="total_bill",
               order=["Thur", "Fri", "Sat", "Sun"])
plt.title("Volvió a la paleta global")
plt.show()

# Restaurar paleta por defecto
sns.set_theme()

Paletas circulares con husl y hls

Para categorías con muchos niveles (más de 6), las paletas circulares distribuyen uniformemente los colores en el espacio perceptual:

n_colores = 12

fig, axes = plt.subplots(3, 1, figsize=(10, 4))

for ax, (nombre, kwargs) in zip(axes, [
    ("husl", {"as_cmap": False}),
    ("hls", {"as_cmap": False}),
    ("cubehelix", {"start": 2, "rot": 0.4, "dark": 0.3, "light": 0.8})
]):
    if nombre == "cubehelix":
        palette = sns.cubehelix_palette(**kwargs, n_colors=n_colores)
    else:
        palette = sns.color_palette(nombre, n_colores)
    sns.palplot(palette, ax=ax)
    ax.set_title(f"'{nombre}' con {n_colores} colores", fontsize=10, loc="left")
    ax.set_xticks([])

plt.tight_layout()
plt.show()

Guía de selección de paleta

| Tipo de variable en hue | Paleta recomendada | Ejemplo | |------------------------|-------------------|---------| | Categórica (≤6 grupos) | colorblind, Set2, tab10 | Especie, género, ciudad | | Categórica (>6 grupos) | husl, hls, tab20 | Países, IDs de usuario | | Numérica creciente | viridis, Blues, rocket | Precio, temperatura, edad | | Numérica con centro | coolwarm, RdBu, vlag | Correlación, diferencia, cambio | | Numérica de baja a alta intensidad | YlOrRd, plasma, inferno | Calor, intensidad, densidad |