Seaborn: Integraciones

Seaborn destaca por su capacidad para integrarse fluidamente con otras bibliotecas del ecosistema de ciencia de datos en Python. Esta característica permite aprovechar las fortalezas de cada biblioteca mientras se mantiene una sintaxis coherente y un flujo de trabajo eficiente. A continuación, exploraremos cómo Seaborn se integra con NumPy, Pandas y Matplotlib, así como sus diferencias con Plotly Express.

La integración con arrays de NumPy representa el nivel más básico de compatibilidad de Seaborn. Aunque Seaborn está diseñado para funcionar óptimamente con DataFrames de Pandas, también puede trabajar directamente con arrays de NumPy para crear visualizaciones estadísticas.

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

# Configurar el estilo de Seaborn
sns.set_theme()

# Crear arrays de NumPy
x = np.random.normal(size=1000)
y = x * 2 + np.random.normal(size=1000)

# Crear visualización con arrays de NumPy
plt.figure(figsize=(10, 6))
sns.scatterplot(x=x, y=y)
plt.title("Gráfico de dispersión con arrays de NumPy")
plt.show()

Para visualizaciones más complejas, podemos seguir utilizando arrays de NumPy, proporcionando los datos para cada parámetro visual específico:

# Datos más complejos con NumPy
np.random.seed(42)
x = np.random.normal(size=100)
y = np.random.normal(size=100)
categorias = np.random.choice(['A', 'B', 'C'], size=100)
tamanios = np.random.randint(10, 100, size=100)

plt.figure(figsize=(10, 6))
sns.scatterplot(
    x=x, 
    y=y, 
    hue=categorias,
    size=tamanios,
    palette="deep",
    sizes=(20, 200)
)
plt.title("Gráfico multidimensional con arrays de NumPy")
plt.show()

Aunque Seaborn puede trabajar con arrays de NumPy, la integración con Pandas proporciona una experiencia mucho más rica y conveniente. Los DataFrames y Series de Pandas permiten a Seaborn aprovechar automáticamente la estructura y metadatos de los datos.

import pandas as pd

# Crear un DataFrame de Pandas
df = pd.DataFrame({
    'x': np.random.normal(size=100),
    'y': np.random.normal(size=100),
    'categoria': np.random.choice(['Grupo A', 'Grupo B', 'Grupo C'], size=100),
    'valor': np.random.uniform(0, 1, size=100)
})

# Visualizar usando el parámetro data
plt.figure(figsize=(10, 6))
sns.scatterplot(
    data=df,
    x='x',
    y='y',
    hue='categoria',
    size='valor',
    sizes=(20, 200)
)
plt.title("Gráfico de dispersión usando DataFrame de Pandas")
plt.show()

El uso de índices y columnas de Pandas facilita la creación de gráficos más informativos. Seaborn aprovecha esta estructura para etiquetar ejes, leyendas y otros elementos del gráfico automáticamente:

# Datos temporales con índice de fecha
fechas = pd.date_range('2025-01-01', periods=100)
datos_temporales = pd.DataFrame({
    'fecha': fechas,
    'valor_a': np.cumsum(np.random.randn(100)),
    'valor_b': np.cumsum(np.random.randn(100))
}).set_index('fecha')

# Gráfico de líneas aprovechando el índice temporal
plt.figure(figsize=(12, 6))
sns.lineplot(data=datos_temporales)
plt.title("Series temporales con índice de fecha de Pandas")
plt.ylabel("Valor acumulado")
plt.show()

La combinación de las operaciones de Pandas con las visualizaciones de Seaborn crea un flujo de trabajo potente para el análisis exploratorio:

# Cargar datos de ejemplo
tips = sns.load_dataset("tips")

# Manipular datos con Pandas y visualizar con Seaborn
resumen_por_dia = tips.groupby(['day', 'time']).agg({
    'total_bill': ['mean', 'std'],
    'tip': ['mean', 'std'],
    'size': 'mean'
}).reset_index()

# Renombrar las columnas para más claridad
resumen_por_dia.columns = ['_'.join(col).rstrip('_') for col in resumen_por_dia.columns.values]

plt.figure(figsize=(12, 6))
sns.barplot(
    data=resumen_por_dia,
    x='day',
    y='total_bill_mean',
    hue='time',
    errorbar=('sd', resumen_por_dia['total_bill_std'])
)
plt.title("Gasto medio por día y horario")
plt.ylabel("Importe medio (€)")
plt.show()

Seaborn también facilita la visualización de datos agrupados y transformados en Pandas:

# Datos de pivote
vuelos = sns.load_dataset("flights")
vuelos_pivot = vuelos.pivot("month", "year", "passengers")

# Mapa de calor con datos pivotados
plt.figure(figsize=(12, 8))
sns.heatmap(
    vuelos_pivot,
    cmap="YlGnBu",
    annot=True,
    fmt="d"
)
plt.title("Número de pasajeros por mes y año")
plt.show()

La interoperabilidad con Matplotlib es una de las características más potentes de Seaborn. En realidad, Seaborn es una capa de abstracción sobre Matplotlib que simplifica la creación de visualizaciones estadísticas, pero mantiene toda la flexibilidad del sistema subyacente.

# Crear un gráfico base con Seaborn
plt.figure(figsize=(10, 6))
ax = sns.barplot(
    data=tips,
    x="day",
    y="total_bill",
    hue="sex"
)

# Personalizar con funciones de Matplotlib
ax.set_title("Gasto por día y género", fontsize=16, color='darkblue')
ax.set_xlabel("Día de la semana", fontweight='bold')
ax.set_ylabel("Importe medio (€)", fontweight='bold')

# Añadir una línea horizontal con Matplotlib
ax.axhline(y=tips['total_bill'].mean(), color='red', linestyle='--', 
          label=f"Media global: {tips['total_bill'].mean():.2f}")

# Personalizar la leyenda con Matplotlib
ax.legend(title="Género", loc="upper right", frameon=True, framealpha=0.8)

# Rotar etiquetas del eje x
plt.xticks(rotation=45)

# Añadir texto con Matplotlib
plt.text(2.5, 30, "Fin de semana", fontsize=12, 
        bbox=dict(facecolor='white', alpha=0.8, boxstyle="round,pad=0.5"))

plt.tight_layout()
plt.show()

Todos los gráficos de Seaborn retornan objetos de Matplotlib, lo que permite una personalización completa después de la creación:

# Crear un grid de facetas de Seaborn
g = sns.FacetGrid(
    tips,
    col="time",
    row="smoker",
    height=4,
    aspect=1.2
)

# Mapear una visualización de Seaborn
g.map_dataframe(sns.scatterplot, x="total_bill", y="tip")

# Personalizar con métodos de Matplotlib
g.set_axis_labels("Importe total", "Propina")
g.set_titles(col_template="{col_name}", row_template="{row_name}")
g.fig.subplots_adjust(top=0.9)  # Ajustar espacio superior
g.fig.suptitle("Relación entre importe y propina", fontsize=16)

# Personalizar subplots individuales
for ax in g.axes.flat:
    # Añadir línea de referencia a cada subplot
    ax.axline((0, 0), slope=0.15, color="red", linestyle="--", alpha=0.5)
    # Personalizar ejes
    ax.grid(True, linestyle=":", alpha=0.6)

plt.show()

La estructura orientada a objetos de Matplotlib se puede utilizar directamente con Seaborn para crear diseños complejos de visualización:

from matplotlib.gridspec import GridSpec

# Crear figura y definir layout con GridSpec
fig = plt.figure(figsize=(14, 8))
gs = GridSpec(2, 3, figure=fig)

# Gráfico principal
ax1 = fig.add_subplot(gs[0, :2])  # Primera fila, dos primeras columnas
sns.scatterplot(
    data=tips,
    x="total_bill",
    y="tip",
    hue="day",
    size="size",
    sizes=(20, 200),
    ax=ax1
)
ax1.set_title("Relación entre importe y propina")

# Histograma horizontal
ax2 = fig.add_subplot(gs[0, 2])  # Primera fila, tercera columna
sns.histplot(
    data=tips,
    y="tip",
    kde=True,
    ax=ax2
)
ax2.set_title("Distribución de propinas")

# Histograma vertical
ax3 = fig.add_subplot(gs[1, 0])  # Segunda fila, primera columna
sns.histplot(
    data=tips,
    x="total_bill",
    kde=True,
    ax=ax3
)
ax3.set_title("Distribución de importes")

# Gráfico de barras
ax4 = fig.add_subplot(gs[1, 1:])  # Segunda fila, últimas dos columnas
sns.barplot(
    data=tips,
    x="day",
    y="total_bill",
    hue="time",
    ax=ax4
)
ax4.set_title("Gasto por día y horario")

plt.tight_layout()
plt.show()

Al comparar Seaborn con Plotly Express, encontramos dos bibliotecas con objetivos similares pero enfoques diferentes. Mientras Seaborn se centra en visualizaciones estadísticas estáticas con una fuerte integración con el ecosistema científico de Python, Plotly Express se orienta a gráficos interactivos para la web.

# Ejemplo equivalente en Seaborn vs Plotly Express

# Seaborn (estático)
plt.figure(figsize=(10, 6))
sns.scatterplot(
    data=tips,
    x="total_bill",
    y="tip",
    hue="day",
    size="size",
    sizes=(20, 200)
)
plt.title("Visualización estática con Seaborn")
plt.show()

# Plotly Express (interactivo) - Código equivalente
import plotly.express as px

fig = px.scatter(
    tips,
    x="total_bill",
    y="tip",
    color="day",
    size="size",
    size_max=20,
    title="Visualización interactiva con Plotly Express"
)
fig.show()

Las principales diferencias conceptuales entre Seaborn y Plotly Express incluyen:

1. Interactividad: Plotly Express crea gráficos interactivos que permiten zoom, paneo, tooltips y selección de datos, mientras que Seaborn produce visualizaciones estáticas (aunque pueden convertirse en interactivas con herramientas adicionales).

2. Salida: Seaborn genera imágenes o archivos estáticos, mientras que Plotly Express genera visualizaciones HTML/JavaScript adecuadas para aplicaciones web y dashboards.

3. Integración: Seaborn se integra profundamente con el ecosistema científico de Python (NumPy, Pandas, Matplotlib), mientras que Plotly Express está diseñado para integrarse con aplicaciones web y frameworks como Dash.

4. Enfoque estadístico: Seaborn incluye funciones estadísticas incorporadas (regresión, estimación de densidad, intervalos de confianza), mientras que Plotly Express se centra más en la visualización de datos sin tanto énfasis en el análisis estadístico.

A pesar de sus diferencias, es posible combinar ambas bibliotecas para aprovechar sus puntos fuertes:

# Análisis estadístico con Seaborn y visualización interactiva con Plotly

# Primero, analizar datos con Seaborn/Pandas
corr = tips.corr()

# Crear mapa de calor estático con Seaborn para