Formación corporativa en Matplotlib

Los gráficos básicos son el punto de partida para cualquier análisis de datos con Matplotlib. En este módulo aprenderás a crear y personalizar los tipos de gráficos más utilizados en ciencia de datos y análisis empresarial.

Tipos de gráficos básicos

Matplotlib ofrece una función específica para cada tipo de gráfico estándar:

• plot(): gráficos de líneas, ideal para series temporales y tendencias
• scatter(): gráficos de dispersión, para visualizar correlaciones entre variables
• bar() / barh(): barras verticales y horizontales, para comparar categorías
• hist(): histogramas, para visualizar la distribución de una variable continua
• pie(): gráficos de pastel, para mostrar proporciones de un todo

¿Cuándo usar cada tipo?

La elección del tipo de gráfico correcto es fundamental para comunicar los datos con claridad:

import matplotlib.pyplot as plt
import numpy as np

fig, axes = plt.subplots(2, 3, figsize=(15, 8))

# Líneas: tendencias temporales
x = np.linspace(0, 10, 100)
axes[0, 0].plot(x, np.sin(x), 'royalblue', linewidth=2)
axes[0, 0].set_title('Líneas: tendencias')

# Barras: comparar categorías
categorias = ['A', 'B', 'C', 'D']
axes[0, 1].bar(categorias, [4, 7, 3, 9], color='coral')
axes[0, 1].set_title('Barras: categorías')

# Scatter: correlaciones
x_sc = np.random.randn(50)
axes[0, 2].scatter(x_sc, x_sc + np.random.randn(50) * 0.5, alpha=0.7)
axes[0, 2].set_title('Scatter: correlaciones')

# Histograma: distribuciones
axes[1, 0].hist(np.random.randn(500), bins=25, color='seagreen', alpha=0.8)
axes[1, 0].set_title('Histograma: distribución')

# Pastel: proporciones
axes[1, 1].pie([35, 25, 20, 20], labels=['A','B','C','D'], autopct='%1.0f%%')
axes[1, 1].set_title('Pastel: proporciones')

# Área apilada: composición en el tiempo
t = np.arange(10)
axes[1, 2].stackplot(t, [5+t, 3+t*0.5, 2+t*0.3], alpha=0.7,
                     labels=['X', 'Y', 'Z'])
axes[1, 2].legend(fontsize=8)
axes[1, 2].set_title('Área: composición')

plt.tight_layout()
plt.show()

Personalización de gráficos básicos

Todos los gráficos básicos comparten los mismos métodos de personalización:

ax.set_title('Título del gráfico', fontsize=14)
ax.set_xlabel('Etiqueta eje X', fontsize=11)
ax.set_ylabel('Etiqueta eje Y', fontsize=11)
ax.legend(loc='best')
ax.grid(True, linestyle='--', alpha=0.4)

Dominar estos tipos de gráficos y su personalización es el fundamento para cualquier trabajo de visualización de datos con Python.

Matplotlib ofrece varias opciones para personalizar nuestros gráficos y ajustarlos a nuestras necesidades específicas. La personalización adecuada no solo mejora la estética de nuestras visualizaciones, sino que también aumenta su capacidad para comunicar información de manera efectiva.

El primer aspecto que podemos personalizar es el tamaño de la figura y su resolución. Esto se logra fácilmente al crear la figura mediante el parámetro figsize (en pulgadas) y el parámetro dpi (puntos por pulgada).

import matplotlib.pyplot as plt
import numpy as np

## Crear una figura de 10x6 pulgadas con 100 DPI
plt.figure(figsize=(10, 6), dpi=100)

## Datos de ejemplo
x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y)
plt.title('Función seno')
plt.show()

Los márgenes de la figura también son importantes para aprovechar mejor el espacio disponible. Podemos ajustarlos manualmente con subplots_adjust() o automáticamente con tight_layout().

## Ajuste manual de márgenes
plt.subplots_adjust(left=0.1, right=0.95, top=0.95, bottom=0.1)

## O usar tight_layout para ajuste automático
plt.tight_layout()

La personalización de títulos, etiquetas y leyendas es fundamental para cualquier gráfico. Estas pueden modificarse en términos de tamaño, estilo, color y ubicación.

plt.figure(figsize=(10, 6))
plt.plot(x, np.sin(x), label='Seno')
plt.plot(x, np.cos(x), label='Coseno')

plt.title('Funciones trigonométricas', fontsize=16, fontweight='bold')
plt.xlabel('Ángulo (rad)', fontsize=12)
plt.ylabel('Valor', fontsize=12)
plt.legend(loc='upper right', fontsize=12, frameon=True, framealpha=0.7)

plt.show()

Para la ubicación de la leyenda, puedes utilizar valores como:

• 'best' (ubicación óptima automática)
• 'upper right', 'upper left'
• 'lower right', 'lower left'
• 'center left', 'center right'
• 'lower center', 'upper center'
• 'center'

Los ejes del gráfico pueden personalizarse en diversos aspectos como sus límites, marcas (ticks) y etiquetas. Es recomendable trabajar con el objeto Axes para tener mayor control.

fig, ax = plt.subplots(figsize=(10, 6))
ax.plot(x, np.sin(x))

## Establecer límites de ejes
ax.set_xlim(0, 10)
ax.set_ylim(-1.5, 1.5)

## Personalizar las marcas de los ejes
ax.set_xticks(np.arange(0, 11, 1))
ax.set_yticks(np.arange(-1, 1.1, 0.5))

## Estilo de las marcas y etiquetas
ax.tick_params(axis='both', which='major', labelsize=10, direction='out', length=6, width=1)

## Añadir cuadrícula
ax.grid(True, linestyle='--', alpha=0.7)

plt.show()

La escala de los ejes puede modificarse para representar mejor ciertos tipos de datos. Las escalas más comunes son:

• Logarítmica (log)
• Simétrica logarítmica (symlog)
• Logit (logit)
• Lineal (linear, valor por defecto)

## Gráfica con escala logarítmica en el eje Y
plt.figure(figsize=(10, 6))
plt.plot(x, np.exp(x))
plt.yscale('log')
plt.title('Escala logarítmica en eje Y')
plt.grid(True)
plt.show()

Los estilos de línea permiten diferenciar múltiples series de datos en un mismo gráfico. Matplotlib ofrece varias opciones:

• Línea sólida (-)
• Línea discontinua (--)
• Línea punteada (:)
• Línea punto-raya (-.)

estilos_linea = ['-', '--', '-.', ':']
etiquetas = ['Sólida', 'Discontinua', 'Punto-raya', 'Punteada']

plt.figure(figsize=(10, 6))
for i, estilo in enumerate(estilos_linea):
    plt.plot(x, np.sin(x + i*0.5), linestyle=estilo, linewidth=2, label=etiquetas[i])

plt.legend()
plt.title('Diferentes estilos de línea')
plt.show()

Los marcadores son símbolos utilizados para representar puntos específicos en un gráfico. Algunos de los más utilizados son:

• 'o' - círculo
• 's' - cuadrado
• '^' - triángulo
• '*' - estrella
• '+' - símbolo más
• 'x' - equis

marcadores = ['o', 's', '^', '*', '+', 'x']
nombres = ['Círculo', 'Cuadrado', 'Triángulo', 'Estrella', 'Más', 'Equis']

plt.figure(figsize=(10, 6))
for i, marcador in enumerate(marcadores):
    plt.plot(x[::10], np.sin(x[::10] + i*0.5), marker=marcador, 
             markersize=10, linestyle='-', label=nombres[i])

plt.legend()
plt.title('Diferentes tipos de marcadores')
plt.show()

La personalización de colores es otro aspecto fundamental. Matplotlib permite especificar colores de varias formas:

• Por nombre ('red', 'green', 'blue', etc.)
• Código hexadecimal ('#FF0000' para rojo)
• Tupla RGB (valores de 0 a 1, como (1, 0, 0) para rojo)
• Valor escalar mapeado a un colormap

## Colores por nombre
colores = ['red', 'green', 'blue', 'purple', 'orange']

plt.figure(figsize=(10, 6))
for i, color in enumerate(colores):
    plt.plot(x, np.sin(x + i*0.5), color=color, linewidth=2, label=f'Color: {color}')

plt.legend()
plt.title('Diferentes colores por nombre')
plt.show()

Los mapas de colores (colormaps) son útiles para representar una tercera dimensión en los gráficos. Matplotlib incluye una amplia variedad:

• Secuenciales: 'viridis', 'plasma', 'inferno', 'cividis'
• Divergentes: 'RdBu', 'PiYG', 'coolwarm'
• Cíclicos: 'twilight', 'hsv'
• Cualitativos: 'Set1', 'Set2', 'tab10'

## Datos para contorno
x_grid = np.linspace(-3, 3, 100)
y_grid = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x_grid, y_grid)
Z = np.sin(X) * np.cos(Y)

plt.figure(figsize=(10, 8))
contour = plt.contourf(X, Y, Z, cmap='viridis', levels=20)
plt.colorbar(contour, label='Valor')
plt.title('Gráfico de contorno con colormap viridis')
plt.show()

Los gráficos de barras pueden personalizarse en términos de ancho, color, borde y etiquetas. Una técnica útil es añadir los valores sobre cada barra.

categorias = ['A', 'B', 'C', 'D', 'E']
valores = [25, 40, 30, 55, 15]

plt.figure(figsize=(10, 6))
barras = plt.bar(categorias, valores, width=0.6, edgecolor='black', linewidth=1.5)

## Colorear cada barra individualmente
colores = ['#FF9999', '#66B2FF', '#99FF99', '#FFCC99', '#FF99CC']
for barra, color in zip(barras, colores):
    barra.set_color(color)

## Añadir valor sobre cada barra
for barra in barras:
    altura = barra.get_height()
    plt.text(barra.get_x() + barra.get_width()/2., altura + 1,
             f'{int(altura)}', ha='center', va='bottom', fontsize=11)

plt.title('Gráfico de barras personalizado')
plt.ylim(0, max(valores) * 1.2)  # Ajustar límite del eje Y
plt.show()

Los gráficos de dispersión (scatter) permiten personalizar el tamaño, color y transparencia de los puntos. Esto es útil para representar múltiples dimensiones de datos.

## Generar datos aleatorios
np.random.seed(42)
x_data = np.random.rand(50) * 10
y_data = np.random.rand(50) * 10
sizes = np.random.rand(50) * 500  # Tamaños variables
colors = np.random.rand(50)  # Colores según valor

plt.figure(figsize=(10, 6))
scatter = plt.scatter(x_data, y_data, s=sizes, c=colors, cmap='viridis', 
                     alpha=0.7, edgecolors='black', linewidths=1)

plt.colorbar(scatter, label='Valor de color')
plt.title('Gráfico de dispersión personalizado')
plt.xlabel('Eje X')
plt.ylabel('Eje Y')
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

Matplotlib incluye varios estilos predefinidos que podemos utilizar para cambiar la apariencia general de nuestras gráficas. Algunos de los más populares son:

• 'default' - El estilo por defecto
• 'ggplot' - Estilo similar a ggplot de R
• 'seaborn' - Basado en la biblioteca Seaborn
• 'bmh' - Estilo de blog Bayesiano
• 'dark_background' - Fondo oscuro, útil para presentaciones

## Ver los estilos disponibles
print(plt.style.available)

## Aplicar un estilo predefinido
plt.style.use('ggplot')

plt.figure(figsize=(10, 6))
plt.plot(x, np.sin(x), 'o-', label='Seno')
plt.plot(x, np.cos(x), 'o-', label='Coseno')
plt.title('Gráfico con estilo ggplot')
plt.legend()
plt.show()

## Restaurar el estilo por defecto
plt.style.use('default')

También podemos crear estilos personalizados definiendo un diccionario de parámetros. Esto es útil para mantener un estilo consistente en todos nuestros gráficos.

## Definir un estilo personalizado como diccionario
estilo_personalizado = {
    'axes.facecolor': '#f0f0f0',
    'axes.edgecolor': '#333333',
    'axes.grid': True,
    'grid.color': '#999999',
    'grid.linestyle': '--',
    'axes.labelcolor': '#555555',
    'xtick.color': '#555555',
    'ytick.color': '#555555',
    'text.color': '#333333',
    'font.family': 'serif',
    'font.size': 12,
    'figure.facecolor': 'white',
    'figure.figsize': [10, 6],
    'lines.linewidth': 2,
    'lines.markersize': 8
}

## Aplicar el estilo personalizado
with plt.rc_context(estilo_personalizado):
    plt.figure()
    plt.plot(x, np.sin(x), 'o-', label='Seno')
    plt.plot(x, np.cos(x), 'o-', label='Coseno')
    plt.title('Gráfico con estilo personalizado')
    plt.legend()
    plt.show()

Las anotaciones permiten destacar puntos específicos en la gráfica y añadir explicaciones. Son útiles para guiar al lector a través de la visualización.

plt.figure(figsize=(10, 6))
plt.plot(x, np.sin(x))

## Añadir texto en una posición arbitraria
plt.text(2, 0.5, 'Punto máximo local', fontsize=12)

## Añadir anotación con flecha
plt.annotate('Punto mínimo local', 
             xy=(6.3, -1),       # Coordenadas del punto a señalar
             xytext=(7, -0.5),   # Coordenadas del texto
             arrowprops=dict(facecolor='black', shrink=0.05, width=1.5),
             fontsize=12)

plt.title('Gráfica con anotaciones')
plt.show()

Podemos añadir elementos decorativos como líneas, rectángulos y círculos a nuestras gráficas para resaltar áreas o puntos de interés.

from matplotlib.patches import Rectangle, Ellipse

fig, ax = plt.subplots(figsize=(10, 6))
ax.plot(x, np.sin(x))

## Añadir un rectángulo
rect = Rectangle((2, -0.5), 3, 1, fill=True, facecolor='yellow', 
                 alpha=0.3, edgecolor='black', linestyle='-')
ax.add_patch(rect)

## Añadir una e

Los subplots y layouts permiten crear figuras con múltiples gráficos organizados de forma clara y profesional. Matplotlib ofrece varias herramientas para este propósito, desde la más sencilla hasta la más flexible.

Herramientas de layout en Matplotlib

Crear subplots básicos

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)

fig, axes = plt.subplots(2, 2, figsize=(12, 8), constrained_layout=True)

axes[0, 0].plot(x, np.sin(x), 'royalblue')
axes[0, 0].set_title('Seno')

axes[0, 1].plot(x, np.cos(x), 'coral')
axes[0, 1].set_title('Coseno')

axes[1, 0].hist(np.random.randn(500), bins=25, color='seagreen', alpha=0.8)
axes[1, 0].set_title('Histograma')

axes[1, 1].scatter(np.random.randn(50), np.random.randn(50), alpha=0.7)
axes[1, 1].set_title('Scatter')

fig.suptitle('Dashboard de ejemplo 2×2', fontsize=14)
plt.show()

GridSpec para layouts irregulares

import matplotlib.gridspec as gridspec

fig = plt.figure(figsize=(12, 8))
gs = gridspec.GridSpec(2, 3, figure=fig, width_ratios=[2, 1, 1])

ax_main = fig.add_subplot(gs[:, 0])    # ocupa las 2 filas de la columna 0
ax_top = fig.add_subplot(gs[0, 1:])    # fila 0, columnas 1 y 2
ax_bot1 = fig.add_subplot(gs[1, 1])    # fila 1, columna 1
ax_bot2 = fig.add_subplot(gs[1, 2])    # fila 1, columna 2

# Contenido de ejemplo
ax_main.plot(x, np.sin(x), 'royalblue', linewidth=2)
ax_main.set_title('Gráfico principal')
ax_top.bar(['A', 'B', 'C', 'D'], [4, 7, 3, 9], color='coral')
ax_bot1.hist(np.random.randn(200), bins=15, color='green', alpha=0.7)
ax_bot2.pie([30, 40, 30], labels=['X', 'Y', 'Z'], autopct='%1.0f%%')

plt.tight_layout()
plt.show()

Los gráficos avanzados de Matplotlib permiten representar datos complejos que van más allá de los gráficos básicos: visualizaciones tridimensionales, distribuciones estadísticas detalladas, datos geométricos en coordenadas polares y campos de datos 2D.

Categorías de gráficos avanzados

Gráficos tridimensionales

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-3, 3, 50)
y = np.linspace(-3, 3, 50)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

fig = plt.figure(figsize=(9, 6))
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.9)
ax.set_title('Superficie 3D: sin(√(x²+y²))')
plt.show()

Gráficos de contorno y mapas de calor

fig, axes = plt.subplots(1, 2, figsize=(13, 5), constrained_layout=True)

cf = axes[0].contourf(X, Y, Z, levels=20, cmap='viridis')
fig.colorbar(cf, ax=axes[0])
axes[0].set_title('Contorno relleno')

axes[1].imshow(np.random.rand(10, 10), cmap='hot', aspect='auto')
axes[1].set_title('Mapa de calor')
plt.show()

Gráficos estadísticos

Los boxplots, violines y barras de error son herramientas clave para el análisis estadístico:

• ax.boxplot(): muestra mediana, cuartiles y outliers
• ax.violinplot(): muestra la distribución completa (KDE)
• ax.errorbar(): barras de error para incertidumbre

Gráficos polares

fig, ax = plt.subplots(figsize=(7, 7), subplot_kw={'projection': 'polar'})
theta = np.linspace(0, 2*np.pi, 300)
ax.plot(theta, 1 + np.sin(5*theta), linewidth=2)
ax.fill(theta, 1 + np.sin(5*theta), alpha=0.2)
ax.set_title('Rosa polar')
plt.show()

Cuándo usar cada tipo avanzado

El módulo de estilos y animaciones lleva las visualizaciones de Matplotlib al siguiente nivel: gráficos con identidad visual consistente, animaciones dinámicas y elementos interactivos.

Estilos predefinidos

Matplotlib incluye más de 25 hojas de estilo listas para usar:

import matplotlib.pyplot as plt
import numpy as np

# Ver todos los estilos disponibles
print(plt.style.available[:10])  # primeros 10

# Aplicar un estilo
plt.style.use('seaborn-v0_8-darkgrid')

x = np.linspace(0, 10, 100)
plt.plot(x, np.sin(x), label='sin(x)')
plt.plot(x, np.cos(x), label='cos(x)')
plt.title('Estilo seaborn-v0_8-darkgrid')
plt.legend()
plt.show()

plt.rcdefaults()

rcParams: configuración global

import matplotlib as mpl

mpl.rcParams.update({
    'figure.figsize': [10, 6],
    'font.size': 12,
    'axes.grid': True,
    'lines.linewidth': 2,
})

Colormaps: tipos y elección

El módulo de integraciones y producción cubre cómo llevar Matplotlib más allá del análisis exploratorio: integración con las bibliotecas del ecosistema científico de Python y exportación de gráficos para publicaciones, aplicaciones web e informes automatizados.

Integración con NumPy

NumPy y Matplotlib nacieron juntos. Los arrays de NumPy son la estructura de datos nativa de Matplotlib:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 500)
y = np.sin(x) * np.exp(-x / 10)

plt.plot(x, y)
plt.title('Onda amortiguada con NumPy + Matplotlib')
plt.show()

Integración con Pandas

Pandas tiene métodos integrados de visualización que usan Matplotlib como motor:

import pandas as pd

df = pd.DataFrame({
    'Producto': ['A', 'B', 'C', 'D'],
    'Ventas': [120, 85, 150, 95]
})

df.plot(kind='bar', x='Producto', y='Ventas', legend=False, figsize=(8, 5))
plt.title('Ventas por producto')
plt.tight_layout()
plt.show()

Exportación de gráficos

fig.savefig('grafico.png', dpi=150, bbox_inches='tight')
fig.savefig('grafico.pdf', bbox_inches='tight')
fig.savefig('grafico.svg', bbox_inches='tight')
fig.savefig('grafico.png', transparent=True, bbox_inches='tight')