Seaborn vs Matplotlib

¿Qué diferencia a Seaborn de Matplotlib?

Seaborn y Matplotlib son dos bibliotecas de visualización de datos en Python que se complementan en lugar de competir. Entender su relación arquitectónica es clave para usarlas eficientemente.

Matplotlib es la biblioteca de visualización de más bajo nivel del ecosistema Python. Proporciona control granular sobre cada elemento del gráfico: figuras, ejes, líneas, marcadores, textos y colores. Es extremadamente flexible pero requiere más código para crear visualizaciones estadísticas complejas.

Seaborn está construido sobre Matplotlib y actúa como una capa de alto nivel orientada específicamente a la estadística y el análisis de datos. Automatiza cálculos estadísticos, integra directamente con DataFrames de Pandas y aplica estilos visuales mejorados por defecto.

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

tips = sns.load_dataset("tips")

Comparativa: el mismo gráfico con cada biblioteca

La diferencia más inmediata se aprecia al crear el mismo gráfico con cada herramienta.

Con Matplotlib puro (diagrama de caja por categorías):

import matplotlib.pyplot as plt
import numpy as np

dias = ["Jue", "Vie", "Sáb", "Dom"]
datos_por_dia = [
    tips[tips["day"] == "Thur"]["total_bill"].values,
    tips[tips["day"] == "Fri"]["total_bill"].values,
    tips[tips["day"] == "Sat"]["total_bill"].values,
    tips[tips["day"] == "Sun"]["total_bill"].values,
]

fig, ax = plt.subplots(figsize=(8, 5))
bp = ax.boxplot(datos_por_dia, labels=dias, patch_artist=True)

colores = ["#4C72B0", "#DD8452", "#55A868", "#C44E52"]
for parche, color in zip(bp["boxes"], colores):
    parche.set_facecolor(color)
    parche.set_alpha(0.7)

ax.set_title("Total de la cuenta por día (Matplotlib)", fontsize=14)
ax.set_xlabel("Día")
ax.set_ylabel("Total ($)")
plt.tight_layout()
plt.show()

Con Seaborn (resultado equivalente en dos líneas):

sns.boxplot(data=tips, x="day", y="total_bill", order=["Thur", "Fri", "Sat", "Sun"])
plt.title("Total de la cuenta por día (Seaborn)")
plt.show()

Seaborn gestiona automáticamente los colores, el estilo y la disposición de los elementos. El código es significativamente más conciso para el mismo resultado visual.

Cuándo usar Matplotlib

Matplotlib es la elección correcta cuando:

• Necesitas un control preciso sobre cada elemento visual (posición exacta de textos, formas personalizadas, composiciones complejas de figuras).
• Vas a crear tipos de gráficos muy específicos que Seaborn no cubre (diagramas polares, gráficos 3D, animaciones).
• Quieres integrar visualizaciones en aplicaciones GUI (Tkinter, PyQt, wxPython).
• Trabajas con datos que no son tabulares (matrices de imágenes, señales de audio, coordenadas geoespaciales).

# Caso de uso típico de Matplotlib: diagrama polar
fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(111, projection="polar")

categorias = ["Velocidad", "Resistencia", "Potencia", "Técnica", "Táctica"]
valores = [4, 3, 5, 4, 3]
valores += valores[:1]  # cerrar el polígono

angulos = np.linspace(0, 2 * np.pi, len(categorias), endpoint=False).tolist()
angulos += angulos[:1]

ax.plot(angulos, valores, "o-", linewidth=2, color="#4C72B0")
ax.fill(angulos, valores, alpha=0.25, color="#4C72B0")
ax.set_xticks(angulos[:-1])
ax.set_xticklabels(categorias, size=12)
ax.set_title("Perfil del jugador", size=16, pad=20)
plt.show()

Cuándo usar Seaborn

Seaborn es la elección óptima cuando:

• Realizas análisis exploratorio de datos (EDA) con DataFrames de Pandas.
• Necesitas gráficos estadísticos con estimaciones de incertidumbre (intervalos de confianza, bootstrapping).
• Quieres crear visualizaciones atractivas rápidamente sin configuración manual extensa.
• Trabajas con datos categóricos y necesitas comparar distribuciones entre grupos.
• Necesitas faceting (múltiples subgráficos condicionados a variables categóricas).

# Caso de uso típico de Seaborn: análisis multivariante con faceting
penguins = sns.load_dataset("penguins")

sns.relplot(
    data=penguins,
    x="bill_length_mm",
    y="bill_depth_mm",
    hue="species",
    size="body_mass_g",
    style="sex",
    col="island",
    height=4,
    aspect=0.9,
    sizes=(20, 200),
    alpha=0.7
)
plt.suptitle("Características morfológicas de pingüinos por isla", y=1.02)
plt.show()

Combinando ambas: lo mejor de los dos mundos

La estrategia más poderosa es usar Seaborn para crear el gráfico y Matplotlib para personalizar los detalles. Seaborn devuelve objetos Axes de Matplotlib, por lo que cualquier personalización de Matplotlib es aplicable:

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset("tips")

# Seaborn crea el gráfico base
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

ax1 = sns.histplot(
    data=tips,
    x="total_bill",
    hue="time",
    kde=True,
    bins=20,
    alpha=0.6,
    ax=axes[0]
)

ax2 = sns.scatterplot(
    data=tips,
    x="total_bill",
    y="tip",
    hue="day",
    size="size",
    sizes=(30, 200),
    ax=axes[1]
)

# Matplotlib personaliza los detalles
axes[0].set_title("Distribución del importe por turno", fontsize=13, fontweight="bold")
axes[0].set_xlabel("Importe total ($)", fontsize=11)
axes[0].set_ylabel("Número de cuentas", fontsize=11)
axes[0].axvline(x=tips["total_bill"].median(), color="red", linestyle="--",
                label=f"Mediana: {tips['total_bill'].median():.1f}")
axes[0].legend()

axes[1].set_title("Importe vs propina por día", fontsize=13, fontweight="bold")
axes[1].set_xlabel("Importe total ($)", fontsize=11)
axes[1].set_ylabel("Propina ($)", fontsize=11)

fig.suptitle("Análisis del dataset tips", fontsize=16, fontweight="bold", y=1.02)
plt.tight_layout()
plt.show()

Diferencias en el manejo de ejes

Una diferencia técnica importante es cómo cada biblioteca gestiona los ejes. Matplotlib usa la interfaz plt. (stateful) o la interfaz ax. (orientada a objetos). Seaborn siempre devuelve el objeto Axes o acepta uno mediante el parámetro ax:

# Interfaz orientada a objetos: la forma recomendada
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# Seaborn sobre ax1
sns.violinplot(data=tips, x="day", y="total_bill", ax=ax1, palette="muted")
ax1.set_title("Distribución por día")

# Matplotlib sobre ax2
ax2.scatter(tips["total_bill"], tips["tip"],
            c=tips["size"], cmap="viridis", alpha=0.6, s=80)
ax2.set_title("Importe vs propina")
ax2.set_xlabel("Total ($)")
ax2.set_ylabel("Propina ($)")

plt.tight_layout()
plt.show()

Seaborn vs otras bibliotecas: contexto general

Para completar la imagen, Seaborn también se diferencia de otras bibliotecas de visualización populares:

| Biblioteca | Tipo | Mejor para | |------------|------|-----------| | Matplotlib | Estática, control bajo nivel | Control total, gráficos personalizados | | Seaborn | Estática, estadística | EDA, gráficos estadísticos, publicaciones | | Plotly | Interactiva, web | Dashboards, presentaciones interactivas | | Bokeh | Interactiva, web | Aplicaciones de visualización en navegador | | Altair | Declarativa, web | Gramática de gráficos, visualización de datos |

La elección depende del contexto de uso: para análisis exploratorio y publicaciones científicas, Seaborn es la herramienta más eficiente. Para dashboards interactivos, Plotly o Bokeh son más adecuados.