Tutoriales 12 min de lectura

Visualización de Datos con Matplotlib y Seaborn en Python: Guía Práctica

Aprende a crear gráficos profesionales con Matplotlib 3.10 y Seaborn 0.13 en Python. Incluye código funcional para histogramas, boxplots, heatmaps, PairGrid, FacetGrid y dashboards multi-panel.

Editorial Team

Introducción: por qué la visualización de datos es una habilidad imprescindible

Puedes tener el dataset más limpio del mundo, el pipeline de preprocesamiento más elegante y un modelo con un accuracy del 97%. Pero si no eres capaz de mostrar lo que encontraste de forma clara y convincente, todo ese trabajo se queda a medio camino.

La visualización de datos no es decoración. Es el puente entre el análisis técnico y la toma de decisiones. Y honestamente, después de años trabajando con datos en Python, puedo decirte que un buen gráfico vale más que diez páginas de métricas en un informe.

En el ecosistema Python, dos librerías dominan este espacio desde hace años: Matplotlib y Seaborn. Matplotlib te da control absoluto sobre cada píxel del gráfico — literalmente puedes ajustar cualquier detalle. Seaborn, construida sobre Matplotlib, te permite crear gráficos estadísticos profesionales con pocas líneas de código. Juntas, forman un tándem que cubre prácticamente cualquier necesidad de visualización en ciencia de datos.

En esta guía vas a aprender a usar ambas librerías de forma práctica, con código que puedes copiar y ejecutar directamente. Cubriremos desde los gráficos más básicos hasta visualizaciones multi-panel avanzadas, pasando por las novedades de Matplotlib 3.10 y Seaborn 0.13. Al terminar, vas a tener un arsenal completo de técnicas para comunicar tus hallazgos como un profesional.

Configuración del entorno de trabajo

Antes de crear un solo gráfico, asegúrate de tener las versiones actualizadas. Matplotlib 3.10 trajo mejoras importantes en accesibilidad de colores y gráficos 3D, mientras que Seaborn 0.13 incorporó parámetros como native_scale y fill en sus funciones categóricas.

pip install matplotlib>=3.10 seaborn>=0.13 pandas numpy

Con todo instalado, estas serán las importaciones estándar que usaremos a lo largo de todos los ejemplos:

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

# Configuración global para gráficos más limpios
sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)
plt.rcParams["figure.figsize"] = (10, 6)
plt.rcParams["figure.dpi"] = 100

Usaremos el dataset tips que viene integrado en Seaborn. Es un conjunto clásico de propinas en restaurantes y resulta perfecto para practicar distintos tipos de gráficos (además, es lo suficientemente pequeño como para no complicar las cosas):

df = sns.load_dataset("tips")
print(df.head())
print(f"Filas: {df.shape[0]}, Columnas: {df.shape[1]}")

Fundamentos de Matplotlib: control total sobre tus gráficos

Matplotlib funciona con un modelo de dos capas: la Figure (el lienzo completo) y los Axes (cada gráfico individual dentro del lienzo). Entender esta distinción es fundamental. La primera vez que la entendí de verdad, todo empezó a tener mucho más sentido.

Gráfico de líneas

El gráfico de líneas es el caballo de batalla para mostrar tendencias a lo largo del tiempo o secuencias ordenadas. Sencillo, efectivo, y casi siempre la primera opción cuando tienes datos temporales:

fig, ax = plt.subplots()

x = np.linspace(0, 10, 100)
ax.plot(x, np.sin(x), label="sin(x)", linewidth=2)
ax.plot(x, np.cos(x), label="cos(x)", linewidth=2, linestyle="--")

ax.set_title("Funciones Trigonométricas", fontsize=14, fontweight="bold")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

Gráfico de barras

Ideal para comparar cantidades entre categorías. Aquí calculamos el total de propinas por día de la semana:

propinas_por_dia = df.groupby("day")["tip"].sum().reindex(["Thur", "Fri", "Sat", "Sun"])

fig, ax = plt.subplots()
colores = ["#4C72B0", "#55A868", "#C44E52", "#8172B3"]
barras = ax.bar(propinas_por_dia.index, propinas_por_dia.values, color=colores, edgecolor="white")

# Añadir valores encima de cada barra
for barra in barras:
    altura = barra.get_height()
    ax.text(barra.get_x() + barra.get_width() / 2., altura + 0.5,
            f"${altura:.1f}", ha="center", va="bottom", fontweight="bold")

ax.set_title("Total de Propinas por Día", fontsize=14, fontweight="bold")
ax.set_ylabel("Propinas ($)")
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.show()

Fíjate en ese detalle de ax.spines[["top", "right"]].set_visible(False). Quitar los bordes superior y derecho es un truco rápido que hace que cualquier gráfico se vea mucho más limpio. Pequeño cambio, gran diferencia.

Gráfico de dispersión con personalización avanzada

El scatter plot revela relaciones entre dos variables numéricas. Lo bueno de Matplotlib es que puedes mapear una tercera (y hasta cuarta) variable al tamaño o color de los puntos:

fig, ax = plt.subplots()

scatter = ax.scatter(
    df["total_bill"], df["tip"],
    c=df["size"], cmap="viridis",
    s=df["size"] * 30, alpha=0.7, edgecolors="white", linewidth=0.5
)

ax.set_title("Propina vs. Cuenta Total", fontsize=14, fontweight="bold")
ax.set_xlabel("Cuenta Total ($)")
ax.set_ylabel("Propina ($)")

cbar = plt.colorbar(scatter, ax=ax)
cbar.set_label("Tamaño del grupo")

plt.tight_layout()
plt.show()

Subplots: múltiples gráficos en un lienzo

La función subplots es tu mejor aliada para crear dashboards estáticos. Puedes organizar gráficos en filas y columnas, y es la forma más directa de presentar varios análisis de un vistazo:

fig, axes = plt.subplots(1, 3, figsize=(16, 5))

# Histograma
axes[0].hist(df["total_bill"], bins=20, color="#4C72B0", edgecolor="white")
axes[0].set_title("Distribución de Cuentas")
axes[0].set_xlabel("Cuenta Total ($)")

# Boxplot
axes[1].boxplot([df[df["sex"] == "Male"]["tip"],
                 df[df["sex"] == "Female"]["tip"]],
                labels=["Hombre", "Mujer"])
axes[1].set_title("Propinas por Género")
axes[1].set_ylabel("Propina ($)")

# Pie chart
fumadores = df["smoker"].value_counts()
axes[2].pie(fumadores.values, labels=["No fumador", "Fumador"],
            autopct="%1.1f%%", colors=["#55A868", "#C44E52"])
axes[2].set_title("Distribución Fumadores")

plt.suptitle("Dashboard: Análisis del Dataset Tips", fontsize=16, fontweight="bold", y=1.02)
plt.tight_layout()
plt.show()

Seaborn: gráficos estadísticos con mínimo código

Seaborn brilla cuando necesitas explorar datos de forma rápida y visualmente atractiva. Su integración nativa con DataFrames de Pandas significa que puedes pasar columnas por nombre en lugar de extraer arrays manualmente. Eso, para el día a día, es una diferencia enorme.

Gráficos de distribución

Entender cómo se distribuyen tus variables es siempre el primer paso del análisis exploratorio. Así que vamos con ello:

fig, axes = plt.subplots(1, 3, figsize=(16, 5))

# Histograma con curva KDE
sns.histplot(data=df, x="total_bill", kde=True, ax=axes[0], color="#4C72B0")
axes[0].set_title("Histograma + KDE")

# KDE por categoría
sns.kdeplot(data=df, x="total_bill", hue="time", fill=True, ax=axes[1])
axes[1].set_title("Densidad por Horario")

# ECDF (distribución acumulativa empírica)
sns.ecdfplot(data=df, x="total_bill", hue="sex", ax=axes[2])
axes[2].set_title("ECDF por Género")

plt.tight_layout()
plt.show()

Gráficos categóricos: boxplot, violinplot y más

Los gráficos categóricos comparan distribuciones entre grupos. Seaborn 0.13 introdujo el parámetro fill que permite alternar entre cajas sólidas y de contorno — un detalle útil cuando quieres superponer varios gráficos sin que se vuelva un caos visual:

fig, axes = plt.subplots(1, 3, figsize=(16, 5))

# Boxplot clásico
sns.boxplot(data=df, x="day", y="total_bill", hue="sex", ax=axes[0])
axes[0].set_title("Boxplot por Día y Género")

# Violin plot — muestra la distribución completa
sns.violinplot(data=df, x="day", y="total_bill", hue="smoker",
               split=True, inner="quart", ax=axes[1])
axes[1].set_title("Violin Plot: Fumadores vs No")

# Strip plot — cada punto individual
sns.stripplot(data=df, x="day", y="tip", hue="time",
              dodge=True, alpha=0.6, ax=axes[2])
axes[2].set_title("Strip Plot por Horario")

plt.tight_layout()
plt.show()

Mi favorito personal de los tres es el violin plot con split=True. Te da la distribución completa de ambos grupos lado a lado, algo que el boxplot simplemente no puede hacer.

Gráficos relacionales

Para explorar relaciones entre variables numéricas, Seaborn ofrece funciones especializadas con agregación estadística integrada:

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Scatter plot con línea de regresión
sns.regplot(data=df, x="total_bill", y="tip", ax=axes[0],
            scatter_kws={"alpha": 0.5}, line_kws={"color": "red"})
axes[0].set_title("Regresión: Propina vs Cuenta")

# Scatter con tamaño y color como dimensiones extra
sns.scatterplot(data=df, x="total_bill", y="tip",
                hue="time", size="size", sizes=(20, 200),
                alpha=0.7, ax=axes[1])
axes[1].set_title("Dispersión Multidimensional")

plt.tight_layout()
plt.show()

Mapa de calor: correlaciones de un vistazo

El heatmap es imprescindible en cualquier análisis exploratorio. Si solo pudieras hacer un gráfico antes de empezar a modelar, este sería mi recomendación:

correlacion = df.select_dtypes(include="number").corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(correlacion, annot=True, fmt=".2f", cmap="coolwarm",
            center=0, square=True, linewidths=1, ax=ax,
            cbar_kws={"shrink": 0.8})
ax.set_title("Matriz de Correlación", fontsize=14, fontweight="bold")

plt.tight_layout()
plt.show()

Visualizaciones multi-panel avanzadas con Seaborn

Aquí es donde Seaborn realmente se diferencia. Sus grids multi-panel te permiten explorar relaciones complejas sin escribir bucles manuales. Y créeme, una vez que te acostumbras a usarlos, no hay vuelta atrás.

PairPlot: relaciones por pares en una sola línea

El pairplot genera una matriz de gráficos que muestra la relación entre cada par de variables numéricas, con distribuciones en la diagonal:

sns.pairplot(df, hue="time", diag_kind="kde",
             plot_kws={"alpha": 0.6},
             palette="Set2", corner=True)
plt.suptitle("PairPlot del Dataset Tips", y=1.02, fontsize=14)
plt.show()

El parámetro corner=True elimina los gráficos redundantes del triángulo superior, produciendo una vista más limpia. Si necesitas más control sobre qué aparece en cada zona, usa PairGrid directamente:

g = sns.PairGrid(df, hue="time", vars=["total_bill", "tip", "size"])
g.map_upper(sns.scatterplot, alpha=0.5)
g.map_lower(sns.kdeplot, fill=True, alpha=0.4)
g.map_diag(sns.histplot, kde=True)
g.add_legend()
plt.show()

FacetGrid: el mismo gráfico segmentado por categorías

Mientras que PairGrid muestra distintas relaciones, FacetGrid muestra la misma relación dividida por una o dos variables categóricas. Es perfecto para responder preguntas como "¿esta tendencia se mantiene en todos los subgrupos?":

g = sns.FacetGrid(df, col="time", row="smoker",
                  height=4, aspect=1.2, margin_titles=True)
g.map_dataframe(sns.scatterplot, x="total_bill", y="tip",
                hue="sex", alpha=0.7)
g.add_legend()
g.set_titles(row_template="Fumador: {row_name}", col_template="{col_name}")
g.figure.suptitle("Propina vs Cuenta por Horario y Fumador", y=1.03, fontsize=14)
plt.show()

También puedes usar las funciones de nivel de figura como catplot y relplot, que crean un FacetGrid internamente con una sintaxis más concisa:

sns.catplot(data=df, x="day", y="total_bill", hue="sex",
            col="time", kind="box", height=5, aspect=0.8)
plt.show()

JointPlot: distribución bivariada y marginal

El jointplot combina un gráfico bivariado central con distribuciones marginales en los ejes. Te da una perspectiva completa de la relación entre dos variables en un solo vistazo:

sns.jointplot(data=df, x="total_bill", y="tip",
              kind="hex", color="#4C72B0",
              marginal_kws={"bins": 20})
plt.suptitle("Distribución Conjunta: Cuenta vs Propina", y=1.02)
plt.show()

Prueba distintos valores del parámetro kind: "scatter", "kde", "hist", "hex" y "reg". Cada uno te muestra la misma relación desde un ángulo diferente, y es sorprendente cuánto cambia la historia que cuentan los datos según la representación que elijas.

Mejores prácticas para gráficos profesionales

Crear un gráfico es fácil. Crear uno que comunique de verdad es otra cosa completamente distinta. Estas son las prácticas que marcan la diferencia entre una visualización amateur y una profesional.

1. Elige el gráfico correcto según el objetivo

  • Comparar cantidades → gráfico de barras
  • Mostrar distribuciones → histograma, boxplot, violin plot
  • Revelar relaciones → scatter plot, regplot
  • Mostrar composición → gráfico de barras apiladas, treemap
  • Analizar tendencias → gráfico de líneas
  • Correlaciones globales → heatmap

2. Simplifica sin perder información

Menos es más. Quita todo lo que no aporte información directa al lector:

# Antes: gráfico con exceso de elementos
fig, ax = plt.subplots()
ax.bar(propinas_por_dia.index, propinas_por_dia.values)
ax.grid(True)

# Después: limpio y profesional
fig, ax = plt.subplots()
ax.bar(propinas_por_dia.index, propinas_por_dia.values,
       color="#4C72B0", edgecolor="white", width=0.6)
ax.spines[["top", "right"]].set_visible(False)
ax.set_ylabel("Total Propinas ($)")
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:.0f}"))
plt.tight_layout()
plt.show()

3. Usa paletas de colores con propósito

Los colores no son decoración — comunican información. Elige la paleta según el tipo de dato:

# Paletas secuenciales para datos ordenados
sns.color_palette("Blues", n_colors=5)

# Paletas cualitativas para categorías
sns.color_palette("Set2", n_colors=4)

# Paletas divergentes para datos con punto central
sns.color_palette("coolwarm", n_colors=7)

# Paleta accesible para daltonismo
sns.color_palette("colorblind")

4. Guarda en alta resolución

Nada arruina más un buen gráfico que exportarlo en baja resolución. Siempre usa al menos 300 DPI para impresión y presentaciones:

# Para publicaciones y presentaciones
fig.savefig("grafico_profesional.png", dpi=300, bbox_inches="tight",
            facecolor="white", transparent=False)

# Formato vectorial para máxima calidad
fig.savefig("grafico_profesional.svg", bbox_inches="tight")

# PDF para informes
fig.savefig("grafico_profesional.pdf", bbox_inches="tight")

5. Aplica estilos globales consistentes

Configurar un estilo global al inicio del notebook te ahorra tiempo y asegura que todos los gráficos tengan un aspecto coherente:

# Estilo para presentaciones (fuentes grandes)
sns.set_theme(context="talk", style="whitegrid", palette="colorblind")

# Estilo para notebooks (fuentes medianas)
sns.set_theme(context="notebook", style="ticks", palette="muted")

# Estilo para papers académicos
sns.set_theme(context="paper", style="white", font="serif")

Ejemplo completo: EDA visual de un dataset real

Vamos a poner todo junto en un análisis exploratorio visual completo del dataset tips. Este es exactamente el tipo de dashboard que incluirías en un informe o notebook profesional:

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

# Cargar datos y configurar estilo
df = sns.load_dataset("tips")
sns.set_theme(style="whitegrid", palette="muted", font_scale=1.05)

# Crear dashboard de 6 paneles
fig, axes = plt.subplots(2, 3, figsize=(18, 10))

# Panel 1: Distribución de cuentas
sns.histplot(data=df, x="total_bill", kde=True, ax=axes[0, 0], color="#4C72B0")
axes[0, 0].set_title("Distribución de Cuentas")

# Panel 2: Propinas por día
sns.boxplot(data=df, x="day", y="tip",
            order=["Thur", "Fri", "Sat", "Sun"], ax=axes[0, 1])
axes[0, 1].set_title("Propinas por Día")

# Panel 3: Correlación
corr = df.select_dtypes(include="number").corr()
sns.heatmap(corr, annot=True, fmt=".2f", cmap="coolwarm",
            center=0, ax=axes[0, 2], square=True)
axes[0, 2].set_title("Correlaciones")

# Panel 4: Relación cuenta-propina
sns.regplot(data=df, x="total_bill", y="tip", ax=axes[1, 0],
            scatter_kws={"alpha": 0.4}, line_kws={"color": "red"})
axes[1, 0].set_title("Regresión: Cuenta vs Propina")

# Panel 5: Violin por horario
sns.violinplot(data=df, x="time", y="total_bill",
               hue="sex", split=True, ax=axes[1, 1])
axes[1, 1].set_title("Distribución por Horario y Género")

# Panel 6: Conteo por día y horario
sns.countplot(data=df, x="day", hue="time",
              order=["Thur", "Fri", "Sat", "Sun"], ax=axes[1, 2])
axes[1, 2].set_title("Registros por Día y Horario")

fig.suptitle("Análisis Exploratorio Visual — Dataset Tips",
             fontsize=16, fontweight="bold")
plt.tight_layout()
plt.show()

Con este dashboard tienes una visión completa del dataset en una sola figura. Es el tipo de visualización que hace que quien la ve entienda los datos sin necesidad de explicaciones adicionales.

Preguntas frecuentes

¿Cuál es la diferencia entre Matplotlib y Seaborn?

Matplotlib es una librería de bajo nivel que te da control total sobre cada elemento del gráfico: ejes, etiquetas, colores, escalas. Seaborn está construida encima de Matplotlib y ofrece una interfaz de alto nivel orientada a gráficos estadísticos. En la práctica, Seaborn te permite crear con 2-3 líneas lo que en Matplotlib puro necesitaría 10-15. La mejor estrategia (y la que uso yo) es crear el gráfico base con Seaborn y luego ajustar los detalles finos con Matplotlib.

¿Cómo elijo entre histplot, kdeplot y ecdfplot para mostrar distribuciones?

Usa histplot cuando quieras ver la frecuencia real de los datos en intervalos concretos — es la opción más intuitiva y la mejor para audiencias no técnicas. Usa kdeplot cuando necesites una estimación suave de la densidad, sobre todo para comparar distribuciones entre grupos. Y ecdfplot es ideal cuando te interese responder preguntas como "¿qué porcentaje de valores está por debajo de X?". Para un análisis exploratorio rápido, histplot(kde=True) te da lo mejor de ambos mundos.

¿Cómo puedo hacer que mis gráficos sean accesibles para personas con daltonismo?

Usa la paleta sns.color_palette("colorblind") que Seaborn incluye por defecto, diseñada para ser distinguible por personas con los tipos más comunes de daltonismo. Pero no te quedes solo con eso: añade patrones (con el parámetro hatch en barras), distintos marcadores en scatter plots, o etiquetas directas. No dependas exclusivamente del color para transmitir información. Matplotlib 3.10 introdujo nuevos ciclos de colores más accesibles que puedes activar globalmente.

¿Cuándo debería usar PairGrid en lugar de pairplot?

Usa pairplot para una exploración rápida — funciona bien el 80% de las veces y es la opción por defecto. Pasa a PairGrid cuando necesites funciones distintas en el triángulo superior e inferior (por ejemplo, scatter arriba y KDE abajo), cuando quieras transformaciones personalizadas, o cuando necesites control preciso sobre la apariencia de cada panel individual.

¿Puedo crear gráficos interactivos con Matplotlib y Seaborn?

Matplotlib tiene capacidades interactivas limitadas a través de sus backends (por ejemplo, %matplotlib widget en Jupyter), pero no están pensados para producción web. Para gráficos interactivos publicables, la recomendación es usar Plotly o Bokeh. Lo que suelo hacer es usar Matplotlib y Seaborn para el análisis exploratorio y los gráficos estáticos de informes, y luego recrear los gráficos clave en Plotly cuando necesito interactividad en dashboards web.

Sobre el Autor Editorial Team

Our team of expert writers and editors.

Artículos Relacionados