Gráficos de líneas con Matplotlib en Python — Guía completa

La función plot() de Matplotlib es la herramienta principal para gráficos de líneas — diagramas que conectan puntos de datos con una línea continua para mostrar tendencias a lo largo del tiempo o a través de una variable continua. Este capítulo cubre todo, desde tu primer gráfico de onda sinusoidal hasta detalles profesionales como anotaciones, regiones sombreadas y cómo guardar archivos listos para publicación.

Antes de comenzar, asegúrate de que Matplotlib esté instalado:

pip install matplotlib

Si eres nuevo en la biblioteca, consulta primero los capítulos de Introducción a Matplotlib y Primeros pasos.

Cuándo usar un gráfico de líneas

Usa un gráfico de líneas cuando:

• Quieres mostrar tendencias a lo largo del tiempo (precios de acciones, temperatura a lo largo de los meses, pérdida de entrenamiento por épocas).
• El eje x representa una variable continua u ordenada (tiempo, distancia, frecuencia).
• Necesitas comparar múltiples series que comparten el mismo eje x.

Evita los gráficos de líneas para categorías sin orden — un gráfico de barras es más claro en ese caso. Para la relación entre dos variables numéricas independientes sin orden implícito, considera un gráfico de dispersión.

Crear un gráfico de líneas básico

La firma mínima es plt.plot(x, y). Tanto x como y pueden ser listas de Python o arrays de NumPy.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)   # 100 evenly-spaced points from 0 to 10
y = np.sin(x)

plt.plot(x, y)

plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.title('Sine Wave')

plt.tight_layout()
plt.show()

np.linspace(start, stop, num) devuelve num valores equidistantes — una forma conveniente de generar curvas suaves sin escribir un bucle. plt.tight_layout() ajusta el espaciado para que las etiquetas de los ejes nunca queden recortadas; es un buen hábito incluirla antes de cada llamada a show() o savefig().

Cambiar el color y el estilo de la línea

Usar la abreviatura de formato

Pasa una cadena de formato '[color][marcador][estilo de línea]' como tercer argumento posicional:

import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y, 'r--')   # red dashed line

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Red Dashed Sine Wave')
plt.tight_layout()
plt.show()

Letras de color comunes: b azul, g verde, r rojo, c cian, m magenta, y amarillo, k negro, w blanco.

Códigos de estilo de línea comunes: - sólido (predeterminado), -- discontinuo, -. trazo-punto, : punteado.

Usar parámetros con nombre

Los parámetros con nombre son más legibles y ofrecen un control más preciso:

import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(
    x, y,
    color='steelblue',
    linestyle='--',
    linewidth=2,
)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Styled Line')
plt.tight_layout()
plt.show()

Añadir marcadores a los puntos de datos

Los marcadores dibujan un símbolo en cada punto de datos, lo cual es útil cuando los datos sin procesar tienen pocos puntos y quieres mostrarlos explícitamente.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 9)   # only 9 points — markers are visible
y = np.sin(x)

plt.plot(
    x, y,
    color='darkorange',
    linewidth=1.5,
    marker='o',          # circle marker
    markersize=8,
    markerfacecolor='white',
    markeredgewidth=1.5,
)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave with Markers')
plt.tight_layout()
plt.show()

Códigos de marcador comunes: 'o' círculo, 's' cuadrado, '^' triángulo hacia arriba, 'D' diamante, '+' más, 'x' cruz, '*' estrella.

Consulta el capítulo Marcadores de Matplotlib para ver la lista completa y opciones de formato avanzadas.

Trazar múltiples líneas

Llama a plt.plot() más de una vez antes de plt.show(). Cada llamada añade una nueva línea a los mismos ejes. Pasa un argumento label y luego llama a plt.legend() para generar una leyenda automáticamente.

import matplotlib.pyplot as plt
import numpy as np

x  = np.linspace(0, 10, 200)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.sin(x) * np.exp(-x / 5)   # damped sine

plt.plot(x, y1, label='sin(x)', linewidth=1.5)
plt.plot(x, y2, label='cos(x)', linewidth=1.5, linestyle='--')
plt.plot(x, y3, label='damped sin(x)', linewidth=1.5, linestyle='-.')

plt.xlabel('x')
plt.ylabel('y')
plt.title('Multiple Lines')
plt.legend()

plt.tight_layout()
plt.show()

Matplotlib recorre automáticamente su paleta de colores predeterminada, por lo que no necesitas especificar colores diferentes para cada línea a menos que quieras sobrescribirlos.

Controlar los límites de los ejes

plt.xlim() y plt.ylim() establecen el rango visible de cada eje. Pasa (min, max) para acercar o alejar:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y)

plt.xlim(0, 5)     # show only the first half
plt.ylim(-1.2, 1.2)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave (Zoomed In)')
plt.tight_layout()
plt.show()

Para que Matplotlib determine un límite automáticamente mientras se fija el otro, usa None como marcador de posición: plt.xlim(None, 5) deja el límite inferior en automático.

Añadir una cuadrícula

plt.grid(True) añade una cuadrícula ligera que facilita la lectura de valores en el gráfico. Puedes apuntar solo a las marcas mayores o menores y controlar el estilo:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y, color='steelblue', linewidth=2)

plt.grid(True, linestyle='--', color='grey', alpha=0.5)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave with Grid')
plt.tight_layout()
plt.show()

Consulta el capítulo Cuadrícula de Matplotlib para una discusión completa sobre la personalización de la cuadrícula.

Anotar puntos

plt.annotate() dibuja una etiqueta de texto con una flecha opcional que apunta a una coordenada de datos específica. Esto es útil para señalar picos, valles o eventos significativos.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y, color='steelblue', linewidth=1.5)

# Annotate the first peak (approx. x = pi/2)
plt.annotate(
    'peak',
    xy=(np.pi / 2, 1),            # point to annotate
    xytext=(np.pi / 2 + 1, 1.1),  # position of the text
    arrowprops=dict(arrowstyle='->', color='black'),
    fontsize=10,
)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Annotated Sine Wave')
plt.tight_layout()
plt.show()

Rellenar entre líneas

plt.fill_between() sombrea la región entre dos curvas (o entre una curva y una constante). Esto es común para mostrar intervalos de confianza o bandas de incertidumbre.

import matplotlib.pyplot as plt
import numpy as np

x    = np.linspace(0, 10, 200)
y    = np.sin(x)
# Simulate an upper and lower confidence bound
upper = y + 0.3
lower = y - 0.3

plt.plot(x, y, color='steelblue', linewidth=2, label='mean')
plt.fill_between(x, lower, upper, alpha=0.2, color='steelblue', label='±0.3 band')

plt.xlabel('x')
plt.ylabel('Amplitude')
plt.title('Line with Confidence Band')
plt.legend()
plt.tight_layout()
plt.show()

El argumento alpha controla cuán transparente es el sombreado — los valores alrededor de 0.2–0.3 suelen funcionar bien para que la línea permanezca claramente visible.

Usar la API orientada a objetos

Todos los ejemplos anteriores usan la interfaz sin estado plt.*, que es conveniente para scripts de un solo gráfico. Para figuras más complejas (múltiples subgráficos, gráficos incrustados), usa la API orientada a objetos donde trabajas con objetos explícitos Figure y Axes:

import matplotlib.pyplot as plt
import numpy as np

x  = np.linspace(0, 10, 200)
y1 = np.sin(x)
y2 = np.cos(x)

fig, ax = plt.subplots(figsize=(8, 4))

ax.plot(x, y1, label='sin(x)', color='steelblue', linewidth=1.5)
ax.plot(x, y2, label='cos(x)', color='darkorange', linewidth=1.5, linestyle='--')

ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('OO-style Line Plot')
ax.legend()
ax.grid(True, linestyle=':', alpha=0.6)

plt.tight_layout()
plt.show()

La API orientada a objetos refleja las llamadas plt.* con prefijos ax.set_* para etiquetas y títulos. Es el estilo preferido cuando necesitas organizar múltiples gráficos — consulta Subgráficos de Matplotlib para más detalles.

Guardar un gráfico de líneas en un archivo

Usa plt.savefig() antes de plt.show(). Especifica el formato del archivo mediante la extensión:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y, color='steelblue', linewidth=2)
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Saved Line Plot')
plt.tight_layout()

plt.savefig('sine_wave.png', dpi=150)    # raster PNG at 150 dpi
plt.savefig('sine_wave.svg')             # vector SVG (ideal for web/print)

plt.show()

Opciones de formato comunes: png, pdf, svg, eps. Usa svg o pdf cuando necesites una imagen escalable y lista para imprimir. Llama a savefig() antes de show() — después de show() la figura se borra y savefig() produciría una imagen en blanco.

Controlar el tamaño de la figura

La figura predeterminada es de 6,4 × 4,8 pulgadas a 100 dpi. Cámbialo con figsize=(ancho_pulg, alto_pulg):

import matplotlib.pyplot as plt
import numpy as np

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

fig, ax = plt.subplots(figsize=(10, 4))   # wide and short
ax.plot(x, np.sin(x), label='sin', linewidth=1.5)
ax.plot(x, np.cos(x), label='cos', linewidth=1.5, linestyle='--')

ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('Wide Figure')
ax.legend()

plt.tight_layout()
plt.show()

Referencia rápida

Capítulos relacionados

• Introducción a Matplotlib — descripción general de la biblioteca e instalación
• Matplotlib Pyplot — la interfaz pyplot en profundidad
• Marcadores de Matplotlib — formas de marcadores y formato
• Etiquetas de Matplotlib — etiquetas de ejes, títulos y anotaciones
• Cuadrícula de Matplotlib — añadir y dar estilo a las líneas de cuadrícula
• Gráficos de dispersión de Matplotlib — relaciones entre dos variables
• Gráficos de barras de Matplotlib — comparar cantidades entre categorías
• Subgráficos de Matplotlib — múltiples gráficos en una figura