Matplotlib: Integraciones

La integración de Matplotlib con NumPy es fundamental y está presente desde el diseño original de ambas bibliotecas. NumPy nos proporciona estructuras de datos eficientes para manipular grandes conjuntos de datos numéricos, mientras que Matplotlib nos permite visualizarlos.

import numpy as np
import matplotlib.pyplot as plt

# Crear datos usando NumPy
x = np.linspace(0, 2*np.pi, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.sin(x) * np.cos(x)

# Visualizar usando Matplotlib
plt.figure(figsize=(10, 6))
plt.plot(x, y1, label='sin(x)')
plt.plot(x, y2, label='cos(x)')
plt.plot(x, y3, label='sin(x)*cos(x)')
plt.legend()
plt.title('Funciones trigonométricas con NumPy y Matplotlib')
plt.grid(True)
plt.show()

NumPy ofrece funciones matemáticas avanzadas que resultan útiles para preparar datos antes de visualizarlos. Por ejemplo, podemos utilizar operaciones como np.histogram() para crear histogramas, que luego Matplotlib puede representar visualmente.

# Generar datos aleatorios con NumPy
data = np.random.normal(0, 1, 1000)

# Calcular el histograma con NumPy
hist, bins = np.histogram(data, bins=30)

# Visualizar con Matplotlib
plt.figure(figsize=(10, 6))
plt.hist(data, bins=30, alpha=0.7, color='skyblue', edgecolor='black')
plt.title('Histograma de distribución normal')
plt.axvline(data.mean(), color='red', linestyle='dashed', linewidth=2, label=f'Media: {data.mean():.2f}')
plt.axvline(np.median(data), color='green', linestyle='dashed', linewidth=2, label=f'Mediana: {np.median(data):.2f}')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

La integración con Pandas ha llevado la visualización de datos a un nivel superior. Pandas proporciona métodos integrados que utilizan Matplotlib por debajo, permitiendo crear gráficos directamente desde objetos DataFrame o Series sin necesidad de extraer manualmente los datos.

import pandas as pd

# Crear un DataFrame de ejemplo
fechas = pd.date_range('20250101', periods=12, freq='M')
df = pd.DataFrame({
    'Ventas': np.random.randint(100, 200, 12),
    'Gastos': np.random.randint(50, 150, 12),
    'Clientes': np.random.randint(10, 50, 12)
}, index=fechas)

# Gráfico de líneas directamente desde el DataFrame
df[['Ventas', 'Gastos']].plot(figsize=(10, 6), title='Evolución de ventas y gastos 2025')
plt.ylabel('Euros (€)')
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

Pandas facilita enormemente la creación de diversos tipos de gráficos como barras, dispersión, áreas, y más, directamente desde un DataFrame. El método plot() acepta un parámetro kind que especifica el tipo de gráfico que queremos crear.

# Gráfico de barras
df['Ventas'].plot(kind='bar', figsize=(10, 6), color='skyblue', 
                 title='Ventas mensuales 2025')
plt.ylabel('Ventas (€)')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Gráfico de dispersión
df.plot(kind='scatter', x='Ventas', y='Clientes', figsize=(10, 6),
       title='Relación entre ventas y número de clientes',
       s=df['Gastos'], alpha=0.7, c='Gastos', cmap='viridis')
plt.colorbar(label='Gastos (€)')
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

Otra ventaja importante de la integración con Pandas es el manejo automático de fechas e índices categóricos, que suelen ser complejos de manejar con Matplotlib puro.

# Crear datos mensuales
ventas_mensuales = pd.Series(np.random.randint(100, 200, 12), 
                            index=pd.date_range('20250101', periods=12, freq='M'))

# Plotear datos mensuales con manejo automático de fechas
fig, ax = plt.subplots(figsize=(12, 6))
ventas_mensuales.plot(ax=ax, marker='o')
ax.set_title('Ventas mensuales 2025')
ax.set_ylabel('Ventas (€)')
ax.grid(True)

# Formatear el eje X para mostrar solo los meses
import matplotlib.dates as mdates
ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))
plt.show()

Para datos categóricos, los gráficos de Pandas son especialmente útiles al trabajar con tablas de contingencia o datos agrupados.

# Crear datos categóricos
categorias = ['Electrónica', 'Moda', 'Hogar', 'Deporte', 'Libros']
tiendas = ['Tienda A', 'Tienda B', 'Tienda C']

# Crear una tabla de contingencia
ventas_por_categoria = pd.DataFrame(
    np.random.randint(50, 150, size=(len(categorias), len(tiendas))),
    index=categorias, columns=tiendas
)

# Visualizar como gráfico de barras apiladas
ventas_por_categoria.plot(kind='bar', stacked=True, figsize=(10, 6), 
                         title='Ventas por categoría y tienda')
plt.ylabel('Ventas (€)')
plt.legend(title='Tienda')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

Pandas también facilita la visualización de datos faltantes a través de su integración con Matplotlib.

# Crear un DataFrame con datos faltantes
df_missing = pd.DataFrame(np.random.rand(20, 5), columns=['A', 'B', 'C', 'D', 'E'])
df_missing.iloc[3:5, 0] = np.nan
df_missing.iloc[7:9, 1] = np.nan
df_missing.iloc[1:3, 2] = np.nan
df_missing.iloc[15:17, 3] = np.nan
df_missing.iloc[9:11, 4] = np.nan

# Visualizar los datos faltantes
fig, ax = plt.subplots(figsize=(10, 6))
ax.imshow(df_missing.isna(), cmap='binary', aspect='auto')
ax.set_yticks(range(len(df_missing)))
ax.set_xticks(range(len(df_missing.columns)))
ax.set_xticklabels(df_missing.columns)
ax.set_title('Mapa de calor de datos faltantes')
plt.tight_layout()
plt.show()

La integración con Seaborn lleva las visualizaciones a un nivel aún más alto. Seaborn es una biblioteca construida sobre Matplotlib que proporciona una interfaz de alto nivel para crear gráficos estadísticos más atractivos y informativos.

import seaborn as sns

# Configurar el estilo de Seaborn
sns.set_theme(style="whitegrid")

# Usar un conjunto de datos de ejemplo de Seaborn
tips = sns.load_dataset("tips")

# Crear un gráfico con Seaborn que utiliza Matplotlib por debajo
plt.figure(figsize=(10, 6))
sns.scatterplot(data=tips, x="total_bill", y="tip", hue="sex", size="size")
plt.title('Propinas vs Total de la cuenta')
plt.show()

Lo interesante es que Seaborn devuelve objetos de Matplotlib, lo que significa que podemos seguir utilizando todas las funciones de personalización de Matplotlib después de crear un gráfico con Seaborn.

# Crear un gráfico de violín con Seaborn
plt.figure(figsize=(12, 6))
ax = sns.violinplot(data=tips, x="day", y="total_bill", hue="sex", split=True, inner="quart")

# Personalizar con Matplotlib
ax.set_title('Distribución de cuentas por día y género', fontsize=16)
ax.set_xlabel('Día', fontsize=12)
ax.set_ylabel('Total de la cuenta ($)', fontsize=12)
plt.legend(title='Género', title_fontsize=12)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()

Seaborn ofrece gráficos estadísticos avanzados que serían complejos de implementar directamente con Matplotlib, como los gráficos de pares y las matrices de correlación.

# Cargar un conjunto de datos multivariado
iris = sns.load_dataset("iris")

# Crear una matriz de gráficos de pares
plt.figure(figsize=(12, 10))
sns.pairplot(iris, hue="species", diag_kind="kde", markers=["o", "s", "D"])
plt.suptitle('Matriz de gráficos de pares para el conjunto de datos Iris', y=1.02, fontsize=16)
plt.show()

Las matrices de correlación son especialmente útiles para visualizar la relación entre múltiples variables:

# Calcular correlaciones
corr = iris.drop('species', axis=1).corr()

# Crear un mapa de calor
plt.figure(figsize=(10, 8))
sns.heatmap(corr, annot=True, cmap='coolwarm', vmin=-1, vmax=1, 
           square=True, linewidths=.5)
plt.title('Matriz de correlación de características del Iris', fontsize=16)
plt.show()

Seaborn también proporciona funciones para visualizar distribuciones de manera efectiva:

# Visualizar distribuciones con KDE (Kernel Density Estimation)
plt.figure(figsize=(12, 6))
for species in iris['species'].unique():
    subset = iris[iris['species'] == species]
    sns.kdeplot(data=subset, x="sepal_length", shade=True, label=species)

plt.title('Distribución de longitud de sépalo por especie', fontsize=14)
plt.xlabel('Longitud de sépalo (cm)')
plt.legend(title='Especie')
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

Una de las grandes ventajas de Seaborn es su capacidad para crear gráficos basados en facetas, que permiten dividir los datos en subconjuntos según una o más variables categóricas.

# Crear un gráfico facetado
g = sns.FacetGrid(tips, col="time", row="smoker", margin_titles=True, height=4)
g.map_dataframe(sns.scatterplot, x="total_bill", y="tip")
g.add_legend()
g.fig.suptitle('Relación entre cuentas y propinas por horario y fumador', y=1.02, fontsize=16)
plt.show()

Una integración particularmente útil es el uso de Plotly con Matplotlib. Plotly permite crear gráficos interactivos, mientras que Matplotlib proporciona una base sólida para la visualización estática.

import plotly.express as px
from plotly.offline import plot
import matplotlib.pyplot as plt
from io import BytesIO

# Crear un gráfico con Plotly
fig = px.scatter(iris, x="sepal_width", y="sepal_length", color="species",
                hover_data=['petal_length', 'petal_width'])

# Guardar como HTML interactivo
plot(fig, filename='iris_interactive.html')

# Convertir a imagen estática para usar con Matplotlib
img_bytes = fig.to_image(format="png", width=800, height=600)
img_io = BytesIO(img_bytes)

# Mostrar la imagen en Matplotlib
plt.figure(figsize=(12, 8))
img = plt.imread(img_io)
plt.imshow(img)
plt.axis('off')
plt.title('Gráfico de Plotly mostrado en Matplotlib', fontsize=16)
plt.show()

Para análisis geoespacial, Matplotlib se integra bien con bibliotecas como Cartopy o Geopandas para crear mapas y visualizaciones geográficas.

import geopandas as gpd
from matplotlib.colors import LinearSegmentedColormap

# Cargar un conjunto de datos geoespaciales
world = gpd.read_file(gpd.datasets.get_path(