Primeros pasos
Instalación y primer gráfico
Matplotlib es la base de la graficación en Python. pyplot es la interfaz basada en estado (como MATLAB). Llama siempre a plt.show() para renderizar la figura en un script; en notebooks de Jupyter la figura se renderiza automáticamente al terminar la celda.
# install
pip install matplotlib
import matplotlib.pyplot as plt
import numpy as np
# a simple line plot
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.plot(x, y)
plt.title("Sine Wave")
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.show()Interfaz de estado pyplot
La interfaz pyplot imita a MATLAB: cada llamada opera sobre la figura/ejes 'actuales' rastreados internamente. Es concisa para gráficos rápidos pero puede volverse confusa con múltiples subplots. Usa plt.gcf()/plt.gca() para acceder a los objetos de figura/ejes actuales.
import matplotlib.pyplot as plt
# pyplot tracks the "current" figure and axes
plt.figure() # create a new figure
plt.plot([1, 2, 3], [4, 5, 2])
plt.title("State-based") # applies to the current axes
plt.xlim(0, 4)
plt.ylim(0, 6)
plt.show()
# plt.gcf() -> current figure, plt.gca() -> current axes
print(plt.gca())Figure y Axes (interfaz OO)
La interfaz Orientada a Objetos (OO) es el enfoque recomendado para cualquier cosa más allá de un gráfico simple. Creas una Figure (el lienzo completo) y uno o más Axes (gráficos individuales) e invocas sus funciones. Escala limpiamente a subplots, ejes gemelos y layouts complejos.
import matplotlib.pyplot as plt
import numpy as np
# object-oriented interface: explicit Figure and Axes objects
fig, ax = plt.subplots() # fig is the canvas, ax is a single Axes
x = np.linspace(0, 5, 50)
ax.plot(x, x**2, label="x^2")
ax.plot(x, x**3, label="x^3")
ax.set_title("OO Interface")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.legend()
plt.show()Imports y convenciones comunes
plt es el alias casi universal de pyplot y np para NumPy — casi cualquier tutorial y librería los espera. rcParams es el diccionario de configuración global: fíjalo una vez al principio de un script para fijar DPI, tamaño de fuente, tamaño de figura y muchos otros valores por defecto.
# the universal alias
import matplotlib.pyplot as plt
import numpy as np
# for the OO interface you often see
from matplotlib.figure import Figure
from matplotlib.axes import Axes
# set a global style once
plt.rcParams["figure.dpi"] = 100
plt.rcParams["font.size"] = 11
# inline backend in Jupyter (not needed in scripts)
# %matplotlib inlineBackends y plt.show()
Un backend renderiza la figura: los backends interactivos (TkAgg, Qt5Agg) abren una ventana, los no interactivos (Agg) solo escriben archivos. Llama a matplotlib.use() antes de importar pyplot. plt.show() bloquea en scripts hasta que se cierren las ventanas; en Jupyter, %matplotlib inline incrusta las figuras en el notebook.
import matplotlib
# list available backends
print(matplotlib.rcsetup.all_backends)
# force a backend (do this BEFORE importing pyplot)
# matplotlib.use("Agg") # non-interactive, for saving files
# matplotlib.use("TkAgg") # interactive Tk window
import matplotlib.pyplot as plt
plt.plot([1, 2, 3])
# plt.show() blocks until the window is closed
plt.savefig("out.png") # saving works without any GUI backendGráficos de líneas (plot)
Gráfico de líneas básico
plt.plot(x, y) dibuja una línea que conecta los puntos (x, y) en orden. Si pasas un solo array se usa como y y x pasa por defecto a 0..N-1. plt.grid(True) activa las líneas de cuadrícula. Los puntos se conectan en el orden del array, así que para una curva suave ordena x primero.
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0, 10, 0.5)
y = x * 2
plt.plot(x, y)
plt.title("y = 2x")
plt.xlabel("x")
plt.ylabel("y")
plt.grid(True)
plt.show()Varias líneas
Cada llamada plt.plot() añade una línea nueva a los ejes actuales y avanza automáticamente el ciclo de colores. Pasa un label= a cada una para que plt.legend() pueda identificarlas. Matplotlib maneja los límites de los ejes automáticamente, expandiéndose para encajar el rango mayor.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2 * np.pi, 100)
plt.plot(x, np.sin(x), label="sin")
plt.plot(x, np.cos(x), label="cos")
plt.plot(x, np.sin(x) + np.cos(x), label="sin+cos")
plt.legend()
plt.title("Trig Functions")
plt.show()Estilos de línea y marcadores
La cadena de formato 'color+marcador+estilo de línea' (por ejemplo, 'ro--') es compacta pero críptica. Prefiere los argumentos con nombre explícitos color=, marker=, linestyle= para código legible. Estilos de línea comunes: '-' '--' ':' '-.'. Marcadores comunes: 'o' 's' '^' 'D' 'v' '+' 'x'.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 20)
# format string: [color][marker][linestyle]
plt.plot(x, x, "r-") # red solid line
plt.plot(x, x*2, "go--") # green circles, dashed
plt.plot(x, x*3, "bs:") # blue squares, dotted
plt.plot(x, x*4, "k^-.") # black triangles, dash-dot
# explicit kwargs (clearer, recommended)
plt.plot(x, x*5, color="purple", marker="D",
linestyle="-.", linewidth=2, markersize=6)Colores
Matplotlib acepta muchos formatos de color: nombres ('red'), cadenas hex ('#FF8800'), tuplas RGB(A), nombres de Tableau ('tab:blue'), referencias de ciclo ('C0'..'C9') y cadenas de escala de grises ('0.5'). 'C0' elige el primer color del estilo actual, manteniendo los gráficos consistentes con el ciclo de colores.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, 30)
plt.plot(x, x, color="red") # named color
plt.plot(x, x+0.2, color="#FF8800") # hex RGB
plt.plot(x, x+0.4, color=(0.1, 0.8, 0.2))# RGB tuple 0-1
plt.plot(x, x+0.6, color="C0") # cycle color 0
plt.plot(x, x+0.8, color="tab:purple") # Tableau palette
# gray shorthand: a string of float in [0,1]
plt.plot(x, x+1.0, color="0.5") # mid gray
plt.show()Grosor de línea, alpha y zorder
linewidth controla el grosor del trazo (1.5 por defecto). alpha fija la transparencia y es esencial cuando las curvas se solapan para poder ver lo que hay debajo. zorder controla el apilamiento — los valores mayores se dibujan después (encima). El zorder por defecto es 2 para líneas, 1 para parches.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
# alpha = transparency (0 invisible, 1 opaque)
# zorder = draw order; higher draws on top
plt.fill_between(x, np.sin(x), alpha=0.3, zorder=1)
plt.plot(x, np.sin(x), linewidth=2, zorder=2)
plt.plot(x, np.cos(x), linewidth=4, alpha=0.7, zorder=3)
plt.show()Gráficos step y stairs
plt.step() dibuja funciones escalón útiles para señales digitales y datos discretos; where controla dónde sube el escalón ('pre', 'post', 'mid'). plt.stairs() (3.4+) es el equivalente moderno que toma valores y y bordes de bin separados, y se integra bien con datos tipo hist.
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(5)
y = [1, 3, 2, 4, 3]
# step: like plot but with horizontal/vertical steps
plt.step(x, y, where="post", label="post")
plt.step(x, y + 1, where="mid", label="mid")
plt.step(x, y + 2, where="pre", label="pre")
plt.legend(title="where=")
# stairs (matplotlib 3.4+): step from explicit bin edges
plt.stairs([1, 2, 1], baseline=0)
plt.show()Gráficos de dispersión
Dispersión básica
plt.scatter(x, y) grafica puntos sin líneas conectoras. Es más lento que plt.plot(x, y, 'o') cuando tienes decenas de miles de puntos porque scatter permite que cada punto tenga su propio tamaño y color. Usa plt.plot con un marcador para máxima velocidad con estilo uniforme.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(0)
x = rng.random(50)
y = rng.random(50)
plt.scatter(x, y)
plt.title("Basic Scatter")
plt.xlabel("x")
plt.ylabel("y")
plt.axis("equal") # equal aspect ratio
plt.show()Tamaño y color del marcador
El argumento s es el ÁREA del marcador en puntos al cuadrado (no el radio), así que un s 4 veces mayor es solo 2 veces el radio. El argumento c (color) con cmap mapea un array numérico a un mapa de colores. Usa alpha < 1 cuando los puntos se solapan para que la densidad sea visible.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(1)
n = 50
x = rng.random(n)
y = rng.random(n)
sizes = rng.random(n) * 500 # area in points^2
colors = rng.random(n) # mapped to colormap
plt.scatter(x, y, s=sizes, c=colors, cmap="viridis", alpha=0.6)
plt.colorbar(label="value")
plt.title("Bubble Chart")
plt.show()Dispersión con mapa de colores
Pasar un array 1-D a c mapea cada punto a un mapa de colores; plt.colorbar(sc) añade una barra de color (debes pasar el valor de retorno del scatter para que la barra conozca el mapeo). vmin/vmax fijan el rango del mapa de colores; sin ellos matplotlib autoescala al mínimo/máximo de los datos.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 200)
y = np.sin(x)
c = x # color by x value
sc = plt.scatter(x, y, c=c, cmap="plasma", vmin=0, vmax=10)
cb = plt.colorbar(sc)
cb.set_label("x position")
plt.title("Colored by x")
plt.show()Transparencia y sobregraficación
Con muchos puntos solapados un scatter sólido oculta la densidad. Baja alpha a ~0.05 y reduce el marcador para revelar la estructura. Para datos muy grandes (100k+ puntos), plt.hexbin o plt.hist2d agregan en bins y son más rápidos y claros que un scatter crudo.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(2)
n = 5000
x = rng.normal(0, 1, n)
y = rng.normal(0, 1, n)
# dense scatter: low alpha reveals density
plt.scatter(x, y, s=5, alpha=0.05, c="navy")
plt.title("Density via alpha")
# alternative: hexbin for very large datasets
plt.figure()
plt.hexbin(x, y, gridsize=40, cmap="Blues")
plt.colorbar(label="count")
plt.show()Dispersión categórica
Matplotlib no tiene strip plot integrado, así que scatter con jitter manual en el eje x es el enfoque DIY estándar. Para gráficos categóricos de calidad editorial (cajas, violines, swarm) prefiere Seaborn, que se construye sobre Matplotlib y se integra con el estilo de plt.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(3)
groups = ["A", "B", "C"]
data = [rng.normal(0, 1, 30),
rng.normal(2, 1, 30),
rng.normal(1, 1.5, 30)]
for i, d in enumerate(data):
# add jitter on x so points do not stack on one line
jitter = rng.uniform(-0.1, 0.1, len(d))
plt.scatter(np.full(len(d), i) + jitter, d, label=groups[i])
plt.xticks(range(len(groups)), groups)
plt.legend()
plt.show()Gráficos de barras
Gráfico de barras verticales
plt.bar(x, height) dibuja barras verticales; x puede ser cadenas (categórico). El BarContainer devuelto permite anotar o recolorear barras individuales. El bucle con plt.text() etiqueta cada barra — ajusta ha/va ('center'/'bottom') y el desplazamiento y para que las etiquetas queden justo encima de la barra.
import matplotlib.pyplot as plt
categories = ["Apple", "Banana", "Cherry", "Date"]
values = [25, 40, 30, 15]
bars = plt.bar(categories, values, color="tab:blue", edgecolor="black")
# annotate each bar with its value
for bar, v in zip(bars, values):
plt.text(bar.get_x() + bar.get_width()/2, v + 1,
str(v), ha="center", va="bottom")
plt.title("Fruit Sales")
plt.ylabel("units sold")
plt.ylim(0, 50)
plt.show()Gráfico de barras horizontales
plt.barh(y, width) dibuja barras horizontales — ideal para etiquetas de categoría largas que se solaparían en un gráfico vertical. Llama a ax.invert_yaxis() para que el primer ítem aparezca arriba, igual que la gente lee las listas. El ancho por defecto es 0.8.
import matplotlib.pyplot as plt
items = ["Reading", "Coding", "Sleep", "Exercise"]
hours = [2, 6, 8, 1]
plt.barh(items, hours, color="tab:green")
plt.xlabel("hours per day")
plt.title("Daily Activities")
# invert so the first item appears at the top
plt.gca().invert_yaxis()
plt.show()Gráfico de barras agrupadas
Las barras agrupadas colocan dos (o más) series lado a lado desplazando las posiciones x la mitad del ancho de barra. El patrón x +/- w/2 con ancho w las coloca contiguas. Usa np.arange para posiciones x numéricas para que la matemática funcione, y luego reetiqueta con plt.xticks.
import matplotlib.pyplot as plt
import numpy as np
labels = ["Q1", "Q2", "Q3", "Q4"]
a = [20, 35, 30, 35]
b = [25, 32, 34, 20]
x = np.arange(len(labels))
w = 0.35
plt.bar(x - w/2, a, w, label="2023")
plt.bar(x + w/2, b, w, label="2024")
plt.xticks(x, labels)
plt.ylabel("revenue")
plt.legend()
plt.show()Gráfico de barras apiladas
Las barras apiladas usan el argumento bottom=: cada serie empieza donde terminó la anterior. Para más de dos series, acumula: bottom = [m+w for m, w in zip(men, women)]. Las barras apiladas muestran totales y composición, pero hacen que las series superiores sean más difíciles de comparar entre categorías.
import matplotlib.pyplot as plt
import numpy as np
labels = ["A", "B", "C"]
men = [20, 35, 30]
women = [25, 32, 34]
plt.bar(labels, men, label="Men")
plt.bar(labels, women, bottom=men, label="Women")
plt.legend()
plt.title("Stacked Bars")
plt.show()Barras con barras de error
El argumento yerr añade barras de error verticales; capsize fija la longitud de los extremos. Pasa error_kw para estilizar las barras. Para errores asimétricos pasa yerr=[errores_inferiores, errores_superiores]. Funciona en barh (xerr) y también en plt.errorbar.
import matplotlib.pyplot as plt
import numpy as np
labels = ["A", "B", "C"]
means = [20, 35, 30]
errors = [2, 4, 3]
plt.bar(labels, means, yerr=errors, capsize=6,
color="tab:orange", edgecolor="black",
error_kw={"ecolor": "black", "linewidth": 1.5})
plt.title("Bar with Error Bars")
plt.ylabel("mean value")
plt.show()Histogramas
Histograma básico
plt.hist(x) agrupa los datos en bins y dibuja barras. bins puede ser un entero (número de bins) o una secuencia de bordes explícitos. Por defecto devuelve conteos, así que el eje y es la frecuencia. El valor de retorno es (conteos, bordes_de_bin, parches) que puedes usar para personalizar más.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(0)
data = rng.normal(0, 1, 1000)
plt.hist(data, bins=30)
plt.title("Histogram")
plt.xlabel("value")
plt.ylabel("frequency")
plt.show()Elegir bins
La elección de bins cambia drásticamente el aspecto de un histograma. 'auto' usa el máximo de las reglas de Sturges y Freedman-Diaconis — un valor por defecto sensato. Pasa un array de bordes explícito para control total y bins comparables entre datasets. Muy pocos bins ocultan estructura; demasiados añaden ruido.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(1)
data = rng.normal(0, 1, 1000)
# auto bin selection (Freedman-Diaconis, Sturges, etc.)
plt.hist(data, bins="auto", alpha=0.5, label="auto")
plt.hist(data, bins=10, alpha=0.5, label="10 bins")
plt.hist(data, bins=np.arange(-4, 4, 0.25),
alpha=0.5, label="0.25 width")
plt.legend()
plt.show()Varios histogramas
Los histogramas solapados necesitan alpha < 1 para ver ambas distribuciones; usa colores distintos. Para más de dos grupos, stacked=True evita el desorden pero dificulta la comparación. Considera kdeplot (Seaborn) para curvas de densidad suaves que se superponen más limpiamente que los histogramas.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(2)
a = rng.normal(0, 1, 1000)
b = rng.normal(1, 1.2, 1000)
plt.hist(a, bins=30, alpha=0.6, label="A", color="tab:blue")
plt.hist(b, bins=30, alpha=0.6, label="B", color="tab:orange")
plt.legend()
plt.show()
# stacked alternative
plt.figure()
plt.hist([a, b], bins=30, stacked=True, label=["A", "B"])
plt.legend()
plt.show()Densidad / normalizado
density=True divide los conteos por (total * ancho_de_bin) para que las áreas de las barras sumen 1, produciendo una densidad de probabilidad. Esto hace los histogramas comparables entre tamaños de muestra distintos y permite superponer una PDF teórica. Usa weights= para ponderar muestras individuales.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(3)
data = rng.normal(0, 1, 1000)
# density=True normalizes the area to 1 (PDF)
plt.hist(data, bins=30, density=True, alpha=0.6)
# overlay the theoretical PDF
from scipy.stats import norm
xs = np.linspace(-4, 4, 200)
plt.plot(xs, norm.pdf(xs), "r-", lw=2)
plt.title("Normalized Histogram + PDF")
plt.show()Histograma 2D
plt.hist2d agrupa dos variables en una cuadrícula 2D y colorea cada celda por conteo — el primo discreto del scatter para datos densos. Para una salida más suave usa plt.hexbin (bins hexagonales). Ambos aceptan un cmap y devuelven valores que puedes pasar a colorbar.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(4)
x = rng.normal(0, 1, 10000)
y = x + rng.normal(0, 1, 10000)
plt.hist2d(x, y, bins=40, cmap="Blues")
plt.colorbar(label="count")
plt.title("2D Histogram")
plt.xlabel("x")
plt.ylabel("y")
plt.show()Gráficos de pastel
Gráfico de pastel básico
plt.pie(x, labels) dibuja un pastel a partir de los valores en x. autopct formatea las etiquetas de porcentaje (cadena estilo printf o función). startangle rota el inicio del primer sector. Haz siempre plt.axis('equal') para que el pastel sea un círculo verdadero y no una elipse.
import matplotlib.pyplot as plt
labels = ["Rent", "Food", "Transport", "Fun"]
sizes = [1200, 600, 300, 400]
plt.pie(sizes, labels=labels, autopct="%1.1f%%", startangle=90)
plt.title("Monthly Budget")
plt.axis("equal") # circle, not ellipse
plt.show()Explode y sombras
explode es una tupla de la misma longitud que los tamaños; cada valor desplaza ese sector hacia afuera desde el centro (0 = sin desplazamiento). shadow=True añade una sombra proyectada para dar profundidad. Usa explode con moderación para resaltar una porción — explotar cada sector queda saturado.
import matplotlib.pyplot as plt
labels = ["A", "B", "C", "D"]
sizes = [30, 25, 25, 20]
explode = (0, 0.1, 0, 0) # pull the 2nd wedge out
plt.pie(sizes, labels=labels, explode=explode,
shadow=True, autopct="%1.0f%%",
startangle=140)
plt.title("Exploded Pie")
plt.show()Gráfico de donut
Un donut es simplemente un pastel con agujero: fija wedgeprops={'width': 0.4} para dibujar anillos en lugar de sectores completos. El agujero central puede contener una etiqueta de resumen vía plt.text(0, 0, ...). Los donuts suelen ser más fáciles de leer que los pasteles porque la longitud del anillo codifica el valor mejor que el ángulo del sector.
import matplotlib.pyplot as plt
labels = ["A", "B", "C"]
sizes = [40, 35, 25]
wedges, texts = plt.pie(sizes, labels=labels,
wedgeprops=dict(width=0.4, edgecolor="w"))
plt.title("Donut Chart")
# add center text
plt.text(0, 0, "Total\n100", ha="center", va="center", fontsize=14)
plt.show()Porcentaje y ángulo de inicio
autopct puede ser una función que recibe el porcentaje y devuelve una cadena, permitiéndote mostrar tanto porcentaje como conteo absoluto. startangle + counterclock=False controlan la dirección de los sectores (empezar arriba, ir en sentido horario — el orden de lectura convencional). pctdistance posiciona las etiquetas de porcentaje.
import matplotlib.pyplot as plt
labels = ["North", "South", "East", "West"]
sizes = [32, 24, 28, 16]
colors = ["#4C72B0", "#DD8452", "#55A868", "#C44E52"]
plt.pie(sizes, labels=labels, colors=colors,
autopct=lambda p: f"{p:.1f}%\n({p*sum(sizes)/100:.0f})",
startangle=90, counterclock=False,
pctdistance=0.75)
plt.show()Pastel anidado (concéntrico)
Dos llamadas plt.pie con valores distintos de radius y width crean anillos concéntricos, un 'sunburst' simple. El anillo exterior típicamente muestra las categorías de nivel superior y el interior sus desgloses. Mantén el radio interior menor y añade edgecolor='w' para separar visualmente los sectores.
import matplotlib.pyplot as plt
# outer ring: regions, inner ring: sub-categories
outer = [40, 30, 30]
inner = [20, 20, 15, 15, 25, 5]
outer_labels = ["A", "B", "C"]
inner_labels = ["A1", "A2", "B1", "B2", "C1", "C2"]
plt.pie(outer, labels=outer_labels, radius=1.0,
wedgeprops=dict(width=0.3, edgecolor="w"))
plt.pie(inner, labels=inner_labels, radius=0.7,
wedgeprops=dict(width=0.3, edgecolor="w"))
plt.title("Nested Pie")
plt.show()Subplots y layouts
plt.subplot
plt.subplot(filas, cols, índice) selecciona los ejes (indexados desde 1) en una cuadrícula — la forma heredada estilo MATLAB. El índice corre de izquierda a derecha, arriba abajo. Muta los 'ejes actuales', así que las llamadas plt posteriores dibujan ahí. Prefiere plt.subplots() para código nuevo; es más limpio y devuelve objetos Axes reales.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 50)
# subplot(nrows, ncols, index) -- 1-indexed!
plt.subplot(2, 2, 1)
plt.plot(x, x)
plt.subplot(2, 2, 2)
plt.plot(x, x**2)
plt.subplot(2, 2, 3)
plt.plot(x, x**3)
plt.subplot(2, 2, 4)
plt.plot(x, np.sin(x))
plt.tight_layout()
plt.show()plt.subplots
plt.subplots(nrows, ncols) devuelve (fig, axes) donde axes es un array de NumPy de Axes — indexa como axes[fila, col]. sharex/sharey alinean las marcas y ahorran espacio. fig.suptitle() fija un título a nivel de figura encima del conjunto de subplots. Haz siempre plt.tight_layout() para evitar el solapamiento de etiquetas.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 100)
# one figure, 2x2 grid of Axes, shared x and y
fig, axes = plt.subplots(2, 2, figsize=(8, 6),
sharex=True, sharey=True)
axes[0, 0].plot(x, np.sin(x)); axes[0, 0].set_title("sin")
axes[0, 1].plot(x, np.cos(x)); axes[0, 1].set_title("cos")
axes[1, 0].plot(x, np.tan(x)); axes[1, 0].set_title("tan")
axes[1, 1].plot(x, -np.sin(x)); axes[1, 1].set_title("-sin")
fig.suptitle("Trig Family")
plt.tight_layout()
plt.show()GridSpec
GridSpec da control total sobre los tamaños de subplot — puedes fusionar celdas con slicing (gs[0, :] = fila entera, gs[1:, 2] = columna derecha alta). Usa width_ratios/height_ratios para columnas/filas de tamaño desigual. Es la herramienta estándar para dashboards complejos.
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
fig = plt.figure(figsize=(8, 6))
gs = gridspec.GridSpec(3, 3, figure=fig)
ax1 = fig.add_subplot(gs[0, :]) # full top row
ax2 = fig.add_subplot(gs[1, :2]) # middle, left 2 cols
ax3 = fig.add_subplot(gs[1:, 2]) # right, spans 2 rows
ax4 = fig.add_subplot(gs[2, 0:2]) # bottom-left
ax1.set_title("wide top")
ax3.set_title("tall right")
plt.tight_layout()
plt.show()Compartir ejes
sharex=True (o sharey=True) vincula ejes para que desplazar/zoom en uno actualice los demás — genial para series temporales apiladas. También oculta las etiquetas de marcas redundantes en los ejes interiores. Los grupos compartidos son accesibles vía ax.get_shared_x_axes(); puedes quitar un eje del grupo para desacoplarlo.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
ax1.plot(x, np.sin(x))
ax2.plot(x, np.cos(x))
# zooming on one now zooms both
ax1.set_xlim(0, 5)
# decouple later if needed
# ax2.get_shared_x_axes().remove(ax2)
fig.suptitle("Shared x-axis")
plt.show()Tight layout y constrained
tight_layout() ajusta el espaciado una vez para prevenir el solapamiento de etiquetas, pero no conoce a fig.suptitle — pasa rect para reservar espacio. layout='constrained' (o fig=Figure(layout='constrained')) es la alternativa moderna que recalcula en cada dibujo, maneja suptitle y barras de color correctamente, y se recomienda para código nuevo.
import matplotlib.pyplot as plt
# tight_layout: simple, adjusts subplot spacing
fig, axes = plt.subplots(2, 2)
for ax in axes.flat:
ax.set_xlabel("x label")
ax.set_ylabel("y label")
ax.set_title("a title")
fig.suptitle("tight_layout")
plt.tight_layout()
# leave room for suptitle
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()
# constrained_layout: recomputes on every draw (more robust)
fig, axes = plt.subplots(2, 2, layout="constrained")
fig.suptitle("constrained_layout")
plt.show()Leyendas y anotaciones
Leyenda básica
plt.legend() recoge las etiquetas de cada artista graficado. loc fija la posición dentro de los ejes ('upper right', 'lower left', 'best', ...). Para una leyenda externa, combina bbox_to_anchor=(x, y) (coordenadas fracción de ejes) con loc para anclar esa esquina de la caja de leyenda a ese punto.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, 30)
plt.plot(x, x, label="linear")
plt.plot(x, x**2, label="quadratic")
plt.plot(x, x**3, label="cubic")
plt.legend()
plt.show()
# legend outside the axes
plt.figure()
plt.plot(x, x, label="linear")
plt.plot(x, x**2, label="quadratic")
plt.legend(loc="upper left", bbox_to_anchor=(1, 1))
plt.tight_layout()
plt.show()Posición y columnas de la leyenda
ncol dispone las entradas de la leyenda en varias columnas — útil cuando tienes muchas etiquetas cortas. frameon/framealpha/fancybox controlan la apariencia de la caja de leyenda. title añade un encabezado. Para un aspecto sin borde fija frameon=False; suele verse más limpio en publicaciones.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, 30)
for i in range(1, 6):
plt.plot(x, x**i, label=f"x^{i}")
plt.legend(loc="upper center", ncol=3, fontsize=9,
frameon=True, framealpha=0.9,
title="Powers", title_fontsize=10)
plt.title("Custom Legend")
plt.show()Anotar puntos
ax.annotate(texto, xy, xytext) coloca texto en xytext y (opcionalmente) dibuja una flecha hacia xy. xy está en coordenadas de datos por defecto. arrowprops es un dict de estilos de flecha; arrowstyle='->' es el más común. annotate es mucho más flexible que plt.text para llamadas de atención.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)
plt.plot(x, y)
# mark and label the maximum
idx = np.argmax(y)
plt.annotate(f"max = {y[idx]:.2f}",
xy=(x[idx], y[idx]), # point to annotate
xytext=(x[idx]-1, 0.5), # text position
arrowprops=dict(arrowstyle="->"))
plt.show()Anotar con flechas
arrowprops estiliza el conector: arrowstyle ('->', '-|>', '<->'), color, lw. connectionstyle dobla la flecha — 'arc3,rad=0.3' la curva, 'angle3' hace un codo en ángulo recto, 'bar' añade una barra en T. Estos permiten construir llamadas claras que rodean los datos sin solaparse con las curvas.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 100)
plt.plot(x, x**3 - 3*x)
plt.annotate("local min", xy=(1, -2), xytext=(2, -10),
arrowprops=dict(arrowstyle="->", color="red",
lw=2, connectionstyle="arc3,rad=0.3"))
plt.annotate("local max", xy=(-1, 2), xytext=(-3, 8),
arrowprops=dict(arrowstyle="-|>", color="blue",
connectionstyle="angle3"))
plt.show()Manejadores de leyenda personalizados
Cuando la leyenda por defecto (construida de los artistas graficados) no es lo que quieres, construye tus propios manejadores con Line2D, Patch o Line2D-sin-datos y pasa handles= a legend(). Es esencial para leyendas que combinan líneas, parches y marcadores de dispersión en una sola clave.
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from matplotlib.patches import Patch
plt.plot([1, 2, 3], [1, 4, 9], "o-", color="tab:blue")
plt.plot([1, 2, 3], [1, 8, 27], "s--", color="tab:orange")
custom = [
Line2D([0], [0], color="tab:blue", marker="o", label="squared"),
Line2D([0], [0], color="tab:orange", marker="s", ls="--", label="cubed"),
Patch(facecolor="gray", label="reference band"),
]
plt.legend(handles=custom)
plt.show()Estilos, colores y rcParams
Estilos integrados
plt.style.use(nombre) aplica un aspecto predefinido globalmente; plt.style.context(nombre) lo aplica temporalmente dentro de un bloque with. Estilos populares: 'ggplot', 'seaborn-v0_8-*', 'bmh', 'fivethirtyeight'. Ojo, los estilos de Seaborn se renombraron con el sufijo '-v0_8' en Matplotlib 3.6+.
import matplotlib.pyplot as plt
# list all available styles
print(plt.style.available)
# use a style globally
plt.style.use("seaborn-v0_8-whitegrid")
# or as a context manager (temporary)
with plt.style.context("dark_background"):
plt.figure()
plt.plot([1, 2, 3], [1, 4, 9])
plt.title("dark")
plt.show()
plt.plot([1, 2, 3], [9, 4, 1])
plt.title("default again")
plt.show()Mapas de colores
Los mapas de colores caen en tres familias: secuenciales (viridis, plasma) para datos ordenados 0..N, divergentes (coolwarm, RdBu) para datos con un punto medio significativo (úsalo con vmin/vmax centrado en 0), y cualitativos (Set2, tab10) para categorías distintas. Prefiere mapas perceptualmente uniformes como viridis — son seguros para daltónicos y se imprimen legibles.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
y = np.sin(x)
# sequential, diverging, qualitative
for cmap in ["viridis", "plasma", "coolwarm", "RdBu", "Set2"]:
plt.scatter(x, y, c=x, cmap=cmap, label=cmap)
plt.colorbar(label=cmap)
plt.title(cmap)
plt.show()Ciclo de colores personalizado
axes.prop_cycle (un objeto cycler) define la secuencia de propiedades que se ciclan a medida que añades líneas. Puedes ciclar color, estilo de línea, marcador y más — combina cycler(color=[...]) + cycler(linestyle=[...]) para avanzar ambos simultáneamente. Esto da a cada gráfico una paleta consistente y con marca.
import matplotlib.pyplot as plt
from cycler import cycler
# set the default color cycle for new axes
plt.rcParams["axes.prop_cycle"] = cycler(
color=["#e41a1c", "#377eb8", "#4daf4a", "#984ea3", "#ff7f00"])
for i in range(1, 6):
plt.plot([0, 1, 2], [i]*3, label=f"line {i}", lw=4)
plt.legend()
plt.title("Custom Cycle")
plt.show()rcParams
rcParams es el diccionario maestro de configuración que controla cada valor por defecto — tamaño de figura, DPI, fuentes, grosores de línea, cuadrícula, opciones de savefig. Fija los valores una vez al principio de un script para una salida consistente. plt.rcParams.update({...}) fija varios a la vez. Usa mpl.rcParamsFile o un archivo matplotlibrc para hacer permanentes los valores por defecto.
import matplotlib.pyplot as plt
import matplotlib as mpl
# read / set individual parameters
mpl.rcParams["figure.figsize"] = (8, 4)
mpl.rcParams["figure.dpi"] = 100
mpl.rcParams["font.size"] = 12
mpl.rcParams["axes.grid"] = True
mpl.rcParams["axes.grid.which"] = "both"
mpl.rcParams["savefig.bbox"] = "tight"
# update many at once
plt.rcParams.update({
"axes.titlesize": "large",
"axes.labelsize": "medium",
"lines.linewidth": 2,
})
plt.plot([1, 2, 3])
plt.title("Configured Defaults")
plt.show()Formatos de color
matplotlib.colors proporciona conversión (to_hex, to_rgb), listas de colores con nombre y construcción de mapas de colores. LinearSegmentedColormap.from_list construye un mapa continuo a partir de unos pocos colores ancla. Para mapas categóricos personalizados usa ListedColormap(['#aaa', '#bbb', ...]). Estos te permiten igualar paletas de marca exactamente.
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
# all named colors
print(list(mcolors.CSS4_COLORS)[:5])
# convert between formats
print(mcolors.to_hex((0.1, 0.2, 0.5))) # #1a3380
print(mcolors.to_rgb("#ff8800")) # (1.0, 0.533, 0.0)
# make a custom colormap from a list of colors
cmap = mcolors.LinearSegmentedColormap.from_list(
"rg", ["red", "yellow", "green"])
import numpy as np
plt.imshow(np.linspace(0, 1, 256).reshape(1, -1),
cmap=cmap, aspect="auto")
plt.title("Custom Colormap")
plt.show()Ajustes de ejes
Límites (xlim / ylim)
plt.xlim/plt.ylim (o ax.set_xlim/ax.set_ylim) fijan el rango de datos visible. Pasar None deja un límite en autoescala, por ejemplo set_ylim(None, 5) solo fija el tope. plt.margins() añade padding como fracción del rango de datos en lugar de límites duros.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
plt.plot(x, np.sin(x))
# set explicit limits
plt.xlim(2, 8)
plt.ylim(-1.5, 1.5)
# or autoscale with margin
# plt.margins(x=0.05, y=0.1)
# query current limits
print(plt.xlim()) # (2.0, 8.0)
plt.show()Marcas (ticks)
plt.xticks(posiciones) fija dónde aparecen las marcas; plt.xticks(posiciones, etiquetas) también fija su texto. Pasa una lista vacía para ocultar las marcas por completo. Para ejes numéricos normalmente dejas que MaxNLocator elija las marcas automáticamente y solo lo sobrescribes para ejes categóricos o simbólicos (como múltiplos de pi).
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 100)
plt.plot(x, np.sin(x))
# set tick positions
plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi])
# set positions AND labels
plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi],
["0", "pi/2", "pi", "3pi/2", "2pi"])
# turn off ticks
# plt.xticks([])
plt.show()Formato de marcas
El módulo ticker da control preciso: los Locators deciden DÓNDE van las marcas (MultipleLocator cada N unidades, MaxNLocator hasta N marcas, LogLocator para ejes log); los Formatters deciden el texto de la ETIQUETA (FormatStrFormatter estilo printf, FuncFormatter función arbitraria). Usa localizadores menores para líneas de cuadrícula finas.
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import MultipleLocator, FormatStrFormatter, FuncFormatter
x = np.linspace(0, 5, 100)
plt.plot(x, x**2)
ax = plt.gca()
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.xaxis.set_minor_locator(MultipleLocator(0.25))
ax.yaxis.set_major_formatter(FormatStrFormatter("%.0f"))
# format with a function
ax.yaxis.set_major_formatter(
FuncFormatter(lambda v, p: f"{v/1000:.1f}k"))
plt.show()Escala logarítmica
plt.xscale('log') / plt.yscale('log') cambian un eje a logarítmico — esencial para datos que abarcan órdenes de magnitud. 'symlog' es una escala log con una región lineal cerca de cero para poder mostrar valores negativos. Usa plt.grid(True, which='both') para mostrar las líneas de cuadrícula mayores y menores (espaciadas logarítmicamente).
import matplotlib.pyplot as plt
import numpy as np
x = np.logspace(0, 4, 50) # 10^0 .. 10^4
plt.plot(x, x**2)
# log both axes
plt.xscale("log")
plt.yscale("log")
# symlog: log scale that handles negative/zero values
# plt.yscale("symlog", linthresh=1)
plt.title("Log-Log Plot")
plt.grid(True, which="both", ls="--", alpha=0.5)
plt.show()Relación de aspecto y spines
ax.set_aspect('equal') garantiza un escalado igual para que los círculos sigan siendo círculos — crítico para geometría y mapas. Los spines son las líneas de borde de los ejes; ocultar los de arriba/derecha ('despinado') da un aspecto moderno más limpio popularizado por Seaborn. También puedes mover los spines a posiciones de datos arbitrarias para construir ejes de mira cruzada.
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots()
theta = np.linspace(0, 2*np.pi, 100)
ax.plot(np.cos(theta), np.sin(theta))
# equal data units on x and y (a true circle)
ax.set_aspect("equal")
# hide the top and right spines
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
# move the remaining spines to the center for a cross-hair
# ax.spines["left"].set_position(("data", 0))
# ax.spines["bottom"].set_position(("data", 0))
plt.show()Texto y expresiones matemáticas
Texto en ejes
ax.text(x, y, s) coloca texto en coordenadas de datos por defecto. Pasa transform=ax.transAxes para usar coordenadas fracción de ejes (0,0 = abajo-izquierda, 1,1 = arriba-derecha), que es cómo fijas etiquetas a una esquina sin importar el rango de datos. ha/va controlan la alineación horizontal/vertical.
import matplotlib.pyplot as plt
plt.plot([0, 1], [0, 1])
# ax.text(x, y, s) -- x, y in data coords
plt.text(0.5, 0.5, "center of plot", ha="center", va="center",
fontsize=14, color="red", rotation=30)
# align to axes fraction instead of data coords
plt.text(0.02, 0.98, "top-left", transform=plt.gca().transAxes,
ha="left", va="top", bbox=dict(boxstyle="round", fc="yellow"))
plt.show()suptitle y figtext
fig.suptitle() añade un título que abarca la figura entera (encima del conjunto de subplots); reserva espacio con tight_layout(rect=[...]) o usa layout='constrained'. fig.text(x, y, s) coloca texto en coordenadas fracción de figura (0,0 = abajo-izquierda de la figura), útil para pies y notas de fuente.
import matplotlib.pyplot as plt
fig, axes = plt.subplots(1, 2)
axes[0].plot([1, 2, 3])
axes[1].plot([3, 2, 1])
# figure-level title (above all axes)
fig.suptitle("Main Title", fontsize=16, fontweight="bold")
# arbitrary figure-coordinate text
fig.text(0.5, 0.01, "figure footer text", ha="center", fontsize=9)
plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()Matemáticas LaTeX (mathtext)
Matplotlib tiene un motor mathtext integrado: envuelve la matemática tipo LaTeX en signos de dólar ($...$) y usa cadenas crudas (r"..."). Los comandos comunes funcionan: \frac, \sum, \int, letras griegas \alpha..\omega, superíndices x^2, subíndices x_i. No hace falta instalar LaTeX externo. Usa r-strings para que las barras invertidas sobrevivan a Python.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 100)
plt.plot(x, np.sin(x))
# mathtext: enclose LaTeX in dollar signs
plt.title(r"$\sin(x)$ vs $x$")
plt.xlabel(r"$x$ (radians)")
plt.ylabel(r"$\sin(x)$")
# fractions, sums, greek letters
plt.text(2, 0.5, r"$\frac{a}{b} + \sum_{i=1}^{n} x_i^2$")
plt.text(2, -0.5, r"$\alpha, \beta, \gamma, \pi, \infty$")
plt.show()Propiedades de texto
Cada objeto de texto acepta un conjunto rico de propiedades: fontsize, fontweight ('bold'), fontstyle ('italic'), family ('serif'/'sans-serif'/'monospace'), color y un dict bbox para una caja de fondo. Los objetos de texto se devuelven para poder mutarlos después (útil en animaciones y actualizaciones interactivas).
import matplotlib.pyplot as plt
t = plt.text(0.5, 0.5, "Styled Text",
fontsize=18, fontweight="bold",
fontstyle="italic", family="serif",
color="darkblue",
bbox=dict(boxstyle="round,pad=0.5",
facecolor="lightyellow", edgecolor="black"))
# animate or update properties later
t.set_fontsize(24)
t.set_color("crimson")
plt.show()Anotaciones (textcoords)
El textcoords de annotate controla cómo se interpreta xytext: 'data' (por defecto, unidades de datos), 'offset points' (puntos relativos a xy — genial para apartar etiquetas de un punto), 'axes fraction' (0-1 a lo largo de los ejes) o 'figure fraction'. Mezclar sistemas de coordenadas permite que las llamadas sigan legibles al hacer zoom.
import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4], [1, 4, 2, 3])
# xy in data coords, xytext in points OFFSET from xy
plt.annotate("offset text", xy=(2, 4),
xytext=(15, 15), textcoords="offset points",
arrowprops=dict(arrowstyle="->"))
# xytext in axes fraction
plt.annotate("axes corner", xy=(2, 4),
xytext=(0.8, 0.8), textcoords="axes fraction",
arrowprops=dict(arrowstyle="-|>"))
plt.show()Guardar figuras
Fundamentos de savefig
plt.savefig(ruta) escribe la figura actual en un archivo. Crucialmente, llámalo ANTES de plt.show() — show() termina y puede cerrar/vaciar la figura, así que guardar después produce un archivo en blanco. La extensión del archivo determina el formato automáticamente (.png, .pdf, .svg, .jpg).
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [4, 5, 2])
# save BEFORE plt.show() -- show() clears the figure
plt.savefig("plot.png")
plt.savefig("plot.pdf")
plt.show()Formatos
Elige el formato según el propósito: PNG para pantalla/web, PDF o SVG (vector) para impresión y edición porque escalan sin pixelarse, JPG solo para imágenes tipo foto (pierde nitidez en líneas y texto). Los formatos vectoriales también producen archivos mucho más pequeños para gráficos con pocos elementos. Pasa format= para anular la extensión.
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [1, 4, 9])
# raster formats (pixels)
plt.savefig("plot.png") # lossless, default
plt.savefig("plot.jpg", quality=95)
plt.savefig("plot.tiff", dpi=200)
# vector formats (scale without pixelation)
plt.savefig("plot.pdf") # best for publications
plt.savefig("plot.svg") # editable in Inkscape/Illustrator
# explicit format override
plt.savefig("plot.dat", format="png")DPI y resolución
DPI (puntos por pulgada) fija la resolución de la salida raster: dimensiones en píxeles = figsize * dpi. 72-100 DPI está bien para pantallas; 300+ DPI se exige para impresión. Guarda en formato vectorial (PDF/SVG) para evitar los problemas de resolución por completo. Fija savefig.dpi en rcParams para una salida de alta resolución consistente en un script.
import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(6, 4))
ax.plot([1, 2, 3], [1, 4, 9])
# dpi controls pixel density: width_px = figsize[0] * dpi
plt.savefig("low.png", dpi=72) # 432 x 288 px
plt.savefig("high.png", dpi=300) # 1800 x 1200 px
# set a global default DPI
plt.rcParams["savefig.dpi"] = 300
plt.savefig("global.png")bbox_inches y pad
Por defecto savefig recorta al rectángulo de la figura, lo que puede cortar etiquetas y títulos cerca del borde. bbox_inches='tight' expande la región guardada para incluir la totalidad de los artistas, y luego pad_inches añade un pequeño margen alrededor. Esto es casi siempre lo que quieres — fíjalo como valor por defecto vía rcParams['savefig.bbox']='tight'.
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [1, 4, 9])
plt.title("With Long Title That Might Be Cut Off")
# tight bbox trims whitespace and keeps labels inside
plt.savefig("tight.png", bbox_inches="tight", pad_inches=0.1)
# trim even more aggressively
plt.savefig("tighter.png", bbox_inches="tight", pad_inches=0)
# preview the tight bounding box
# bbox = plt.savefig("x.png", bbox_inches="tight") # returns a BboxTransparente y facecolor
transparent=True hace que el fondo de la figura sea translúcido (canal alfa de un PNG) — ideal para superponer gráficos en diapositivas o páginas web. facecolor fija el color de fondo guardado (anula el color en pantalla). El fondo de los ejes se controla aparte con ax.set_facecolor(). Combina ambos para diseños en capas.
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot([1, 2, 3], [1, 4, 9])
ax.set_facecolor("#f0f0f0")
# transparent background (alpha channel)
plt.savefig("transparent.png", transparent=True)
# explicit figure face color
plt.savefig("colored.png", facecolor="lightblue", edgecolor="none")
# control which elements are saved
plt.savefig("full.png", facecolor=fig.get_facecolor())Gráficos 3D (mplot3d)
Configuración de ejes 3D
Crea ejes 3D con projection='3d' (vía add_subplot o subplot_kw en subplots). Cada función 2D sigue funcionando, además de las específicas de z (set_zlabel, plot_surface, scatter, etc.). El soporte 3D llega vía el toolkit mplot3d, que viene incluido con Matplotlib y no necesita instalación extra.
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
# add a 3D axes via projection
ax = fig.add_subplot(projection="3d")
# or from subplots
# fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("3D Axes")
plt.show()Dispersión 3D
ax.scatter(x, y, z) sobre ejes 3D grafica puntos en el espacio; los argumentos s y c funcionan igual que el scatter 2D. Añade fig.colorbar(sc) para mostrar el mapeo de color. El scatter 3D es genial para explorar clusters, pero ten en cuenta que los gráficos 3D estáticos pueden ocultar la profundidad — rota interactivamente o usa el color para codificar una dimensión.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(0)
n = 200
x = rng.normal(0, 1, n)
y = rng.normal(0, 1, n)
z = rng.normal(0, 1, n)
c = np.sqrt(x**2 + y**2 + z**2)
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
sc = ax.scatter(x, y, z, c=c, cmap="viridis")
fig.colorbar(sc, label="distance from origin")
ax.set_title("3D Scatter")
plt.show()Superficie 3D
plot_surface(X, Y, Z) dibuja una superficie coloreada; X, Y, Z deben ser arrays 2D de forma coincidente producidos por np.meshgrid. rstride/cstride controlan cuántos puntos de cuadrícula se saltan (menor = más suave pero más lento). cmap colorea por Z; añade una barra de color (con shrink para encajar en una figura 3D).
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-5, 5, 80)
y = np.linspace(-5, 5, 80)
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
surf = ax.plot_surface(X, Y, Z, cmap="coolwarm",
rstride=1, cstride=1,
linewidth=0, antialiased=True)
fig.colorbar(surf, shrink=0.5, aspect=10)
ax.set_title("3D Surface")
plt.show()Wireframe y contorno 3D
plot_wireframe dibuja solo las líneas de la cuadrícula (más ligero que una superficie completa, bueno para mostrar estructura). ax.contourf con zdir='z' y offset proyecta contornos rellenos sobre un plano debajo de la superficie — una visualización común '2D-bajo-3D'. Combina superficie + contornos proyectados para gráficos de terreno ricos.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 30)
y = np.linspace(-3, 3, 30)
X, Y = np.meshgrid(x, y)
Z = X * np.exp(-X**2 - Y**2)
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
ax.plot_wireframe(X, Y, Z, color="black", rstride=1, cstride=1)
ax.set_title("Wireframe")
# 3D contour (filled) projected at the bottom
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
ax.contourf(X, Y, Z, zdir="z", offset=-0.5, cmap="viridis")
ax.set_title("3D Contour")
plt.show()Barras 3D
ax.bar3d(x, y, z, dx, dy, dz) dibuja barras rectangulares en posiciones (x, y) que parten de la base z con anchos dx, dy y altura dz. shade=True añade iluminación para una sensación 3D. Aplana los arrays de coordenadas con .ravel() cuando partas de un meshgrid. Las barras 3D pueden ser difíciles de leer — prefiere barras 2D agrupadas cuando puedas.
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
x = np.arange(3)
y = np.arange(3)
X, Y = np.meshgrid(x, y)
X, Y = X.ravel(), Y.ravel()
Z = np.zeros_like(X)
dz = np.array([1, 2, 3, 2, 3, 1, 3, 1, 2])
ax.bar3d(X, Y, Z, dx=0.6, dy=0.6, dz=dz,
shade=True, color="tab:orange")
ax.set_title("3D Bar Chart")
plt.show()Gráficos de contorno
Líneas de contorno
plt.contour(X, Y, Z) dibuja isolíneas donde Z es constante. X, Y vienen de meshgrid. levels fija el número (o valores exactos) de contornos. plt.clabel(cs) etiqueta cada línea con su valor. Los contornos de línea son precisos pero dispersos; combínalos con contourf para regiones rellenas.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)
# line contours
cs = plt.contour(X, Y, Z, levels=15, colors="black", linewidths=0.8)
plt.clabel(cs, inline=True, fontsize=8)
plt.title("Contour Lines")
plt.colorbar(cs)
plt.show()Contornos rellenos
plt.contourf (ojo a la 'f') rellena de color las regiones entre niveles de contorno, dando un aspecto de mapa de calor suave. Como contour necesita X, Y, Z en cuadrícula. levels controla la resolución. contourf es la forma estándar de visualizar campos escalares 2D como temperatura, elevación o densidad de probabilidad.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-2, 2, 100)
y = np.linspace(-2, 2, 100)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2
cf = plt.contourf(X, Y, Z, levels=20, cmap="viridis")
plt.colorbar(cf, label="Z")
plt.title("Filled Contour")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()Etiquetar contornos (clabel)
plt.clabel(cs) anota las líneas de contorno con su valor Z; inline=True rompe la línea para encajar la etiqueta. fmt formatea el número ('%.2f' o una función). Pasa levels=[...] para etiquetar solo isolíneas concretas. Los contornos etiquetados transmiten valores exactos sin necesitar barra de color.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
Z = X * np.exp(-X**2 - Y**2)
cs = plt.contour(X, Y, Z, 10, colors="black")
plt.clabel(cs, inline=True, fontsize=9, fmt="%.2f")
# label only specific levels
# plt.clabel(cs, levels=[-0.1, 0, 0.1])
plt.title("Labeled Contours")
plt.show()Barra de color
plt.colorbar(mapeable) añade una clave de color — pasa siempre el valor de retorno de contour/imshow/scatter para que conozca el mapeo. set_label/set_ticks lo personalizan. En subplots, las barras de color pueden robar espacio a un eje; usa el argumento ax= o fig.colorbar(mapeable, ax=ejes) para controlar la colocación sobre varios ejes.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 100)
y = np.linspace(0, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) + np.cos(Y)
cf = plt.contourf(X, Y, Z, cmap="RdBu")
# basic colorbar
cb = plt.colorbar(cf)
cb.set_label("Z value")
cb.set_ticks([-2, -1, 0, 1, 2])
# place colorbar with specific size and padding
# cb = plt.colorbar(cf, fraction=0.046, pad=0.04)
plt.title("Colorbar Example")
plt.show()meshgrid y griddata
Contour/contourf necesitan datos sobre una cuadrícula regular. Para muestras dispersas, usa scipy.interpolate.griddata para interpolar sobre un meshgrid (modalidades: 'linear', 'nearest', 'cubic'). np.mgrid[...] es una abreviatura cómoda de meshgrid sobre un rango. Graficar los puntos originales encima muestra dónde los datos son dispersos.
import matplotlib.pyplot as plt
import numpy as np
from scipy.interpolate import griddata
# scattered (x, y, z) samples
rng = np.random.default_rng(0)
pts = rng.uniform(-2, 2, (200, 2))
z = np.sin(pts[:,0]) * np.cos(pts[:,1])
# build a regular grid
grid_x, grid_y = np.mgrid[-2:2:100j, -2:2:100j]
# interpolate scattered data onto the grid
grid_z = griddata(pts, z, (grid_x, grid_y), method="cubic")
plt.contourf(grid_x, grid_y, grid_z, levels=20, cmap="plasma")
plt.scatter(pts[:,0], pts[:,1], c="white", s=5, alpha=0.5)
plt.colorbar(label="z")
plt.title("Scattered -> Grid -> Contour")
plt.show()Visualización de imágenes (imshow)
Fundamentos de imshow
plt.imshow(arr) muestra un array 2D como mapa de calor o un array 3D (H, W, 3) como imagen RGB. Por defecto el origen está arriba-izquierda (origin='upper'), siguiendo las convenciones de imagen — fija origin='lower' para ejes estilo matemática. plt.axis('off') oculta las marcas para una visualización limpia de la imagen.
import matplotlib.pyplot as plt
import numpy as np
# a 2D array is shown as a heatmap (color = value)
rng = np.random.default_rng(0)
img = rng.random((10, 10))
plt.imshow(img, cmap="viridis")
plt.colorbar(label="value")
plt.title("imshow of a 2D array")
plt.show()
# a 3D array (H, W, 3 or 4) is shown as an RGB(A) image
rgb = rng.integers(0, 256, (50, 50, 3), dtype=np.uint8)
plt.imshow(rgb)
plt.axis("off")
plt.title("RGB image")
plt.show()Mapa de colores y barra de color
extent=[xmin, xmax, ymin, max] mapea los píxeles del array a coordenadas de datos; sin él imshow usa índices de píxel. origin='lower' pone la fila 0 abajo (convención matemática). aspect='auto' estira la imagen para llenar los ejes; el 'equal' por defecto conserva píxeles cuadrados. Pasa el objeto de imagen a colorbar.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 200)
y = np.linspace(-3, 3, 200)
X, Y = np.meshgrid(x, y)
Z = np.sin(X**2 + Y**2) / (X**2 + Y**2 + 1)
im = plt.imshow(Z, extent=[-3, 3, -3, 3], origin="lower",
cmap="RdBu", aspect="auto")
cb = plt.colorbar(im)
cb.set_label("intensity")
plt.title("imshow with extent")
plt.show()Interpolación
interpolation controla cómo se mezclan los píxeles al ampliar: 'none'/'nearest' muestra bloques nítidos (bueno para mostrar datos de píxel crudos), 'bilinear'/'bicubic' suaviza entre píxeles (bueno para mapas de calor). La interpolación solo cambia la apariencia, no los datos subyacentes. Para arrays pequeños a menudo QUIERES 'nearest' para que las celdas individuales sean visibles.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(1)
small = rng.random((5, 5))
methods = ["none", "bilinear", "bicubic", "nearest"]
fig, axes = plt.subplots(1, 4, figsize=(12, 3))
for ax, m in zip(axes, methods):
ax.imshow(small, interpolation=m, cmap="magma")
ax.set_title(m)
ax.axis("off")
plt.tight_layout()
plt.show()vmin / vmax y norm
vmin/vmax fijan el rango de datos mapeado al mapa de colores (recortando atípicos). Para mapeos no lineales usa norm=: LogNorm para datos que abarcan órdenes de magnitud, TwoSlopeNorm para centrar un mapa divergente en un punto medio significativo (por ejemplo, 0 para anomalías). norm y vmin/vmax son mutuamente excluyentes — pasa solo uno.
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import LogNorm, TwoSlopeNorm
rng = np.random.default_rng(2)
Z = rng.random((50, 50)) * 1000 + 1
# clamp the colormap range
plt.imshow(Z, vmin=100, vmax=500, cmap="viridis")
plt.colorbar()
plt.title("clipped range")
plt.show()
# log-scaled colors
plt.imshow(Z, norm=LogNorm(vmin=1, vmax=1001), cmap="plasma")
plt.colorbar()
plt.title("log scale")
plt.show()
# diverging norm centered on a midpoint
# norm = TwoSlopeNorm(vmin=-1, vcenter=0, vmax=1)Mostrar imagen desde archivo
mpimg.imread carga una imagen en un array de NumPy (float 0-1 para PNG, 0-255 uint8 para JPEG). plt.imshow la muestra; plt.imsave escribe un array de vuelta a disco. Las imágenes RGB conservan sus colores; pasa cmap='gray' para imágenes de un solo canal. Ojo: PIL/pillow es más capaz para procesamiento de imágenes no trivial.
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
# read an image file into a numpy array
img = mpimg.imread("photo.png") # shape (H, W, 3) or (H, W, 4)
print(img.shape, img.dtype)
plt.imshow(img)
plt.axis("off")
plt.show()
# save the (possibly modified) array back to a file
# plt.imsave("out.png", img)
# drop the alpha channel if present
if img.shape[-1] == 4:
img = img[..., :3]Gráficos polares
Ejes polares
projection='polar' convierte unos ejes en coordenadas polares: x es el ángulo (theta, radianes) e y el radio (r). Cada función estándar sigue funcionando, pero opera en (theta, r). Los gráficos polares son ideales para datos direccionales, funciones periódicas y simetrías circulares. Fija las marcas con ax.set_thetagrids y ax.set_rgrids.
import matplotlib.pyplot as plt
import numpy as np
# create a polar axes via projection
fig = plt.figure()
ax = fig.add_subplot(projection="polar")
# or from subplots
# fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
theta = np.linspace(0, 2*np.pi, 100)
ax.plot(theta, np.sin(2*theta))
plt.show()Gráfico de línea polar
Sobre un ax polar, plot(theta, r) dibuja curvas donde theta es el ángulo y r el radio. set_rmax recorta el rango radial; set_rticks y set_thetagrids personalizan las posiciones de las marcas radial/angular. Los gráficos de línea polares muestran limpiamente funciones periódicas — una onda senoidal se envuelve en un bucle cerrado.
import matplotlib.pyplot as plt
import numpy as np
theta = np.linspace(0, 2*np.pi, 200)
fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
ax.plot(theta, 1 + np.cos(theta), label="cardioid")
ax.plot(theta, np.abs(np.sin(2*theta)), label="rose")
ax.set_rmax(2.0)
ax.set_rticks([0.5, 1.0, 1.5])
ax.set_thetagrids([0, 90, 180, 270])
ax.legend(loc="upper right")
plt.show()Radar / gráfico de araña
Un gráfico de radar es un gráfico de línea polar con un eje por categoría. El truco es añadir el primer valor/ángulo al final para que la curva se cierre en un bucle, y rellenar el interior con alpha. Fija xticks a los ángulos de categoría y etiquétalos. Los radares comparan perfiles multivariable pero pueden engañar — úsalos con moderación.
import matplotlib.pyplot as plt
import numpy as np
labels = ["Speed", "Power", "Range", "Comfort", "Price"]
values = [8, 7, 6, 5, 9]
N = len(labels)
# close the loop
angles = np.linspace(0, 2*np.pi, N, endpoint=False).tolist()
values += values[:1]
angles += angles[:1]
fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
ax.plot(angles, values, "o-")
ax.fill(angles, values, alpha=0.25)
ax.set_xticks(angles[:-1])
ax.set_xticklabels(labels)
ax.set_title("Radar Chart")
plt.show()Barra polar (rosa)
Un gráfico de rosa (o barra polar) usa ax.bar sobre ejes polares — cada barra ocupa un sector angular. Útil para histogramas direccionales como distribución de dirección del viento o periodo de olas. Colorea las barras por radio (como se muestra) para una dimensión extra. bottom= puede apilar o desplazar barras desde el centro.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(0)
N = 12
theta = np.linspace(0, 2*np.pi, N, endpoint=False)
widths = 2*np.pi / N
radii = rng.uniform(1, 5, N)
fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
bars = ax.bar(theta, radii, width=widths, bottom=0,
edgecolor="black")
# color bars by radius
for r, bar in zip(radii, bars):
bar.set_facecolor(plt.cm.viridis(r / radii.max()))
ax.set_title("Rose Diagram")
plt.show()Ajustes polares
set_theta_zero_location('N') mueve 0 radianes arriba y set_theta_direction(-1) hace que los ángulos aumenten en sentido horario — la convención de la brújula. set_rlabel_position(ángulo) reubica las etiquetas de las marcas radiales en cualquier ángulo para no solaparse con los datos. Estos ajustes convierten un gráfico polar matemático en un gráfico direccional/brújula.
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
ax.plot(np.linspace(0, 2*np.pi, 100), np.linspace(0, 1, 100))
# rotate 0 degrees to the top, go clockwise
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
# radial limits and ticks
ax.set_rlim(0, 1.2)
ax.set_rticks([0.25, 0.5, 0.75, 1.0])
ax.set_rlabel_position(135) # move radial labels out of the way
# label directions in degrees
ax.set_thetagrids([0, 90, 180, 270], labels=["E","N","W","S"])
plt.show()Ejes gemelos
twinx (Y secundario)
ax.twinx() crea ejes nuevos que comparten el eje x pero tienen su propio eje y a la derecha — la forma estándar de graficar dos cantidades con unidades distintas (por ejemplo, temperatura y humedad). Colorea cada eje y sus marcas para que coincidan con la curva y los lectores sepan qué escala pertenece a qué serie.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
fig, ax1 = plt.subplots()
ax1.plot(x, np.sin(x), "b-")
ax1.set_xlabel("x")
ax1.set_ylabel("sin(x)", color="b")
ax1.tick_params(axis="y", labelcolor="b")
# a second axes sharing the same x, with an independent y
ax2 = ax1.twinx()
ax2.plot(x, x*10, "r-")
ax2.set_ylabel("10*x", color="r")
ax2.tick_params(axis="y", labelcolor="r")
plt.title("twinx: two y-scales")
plt.show()twiny (X secundario)
ax.twiny() es el homólogo horizontal: ejes nuevos que comparten el eje y pero con su propio eje x arriba. Úsalo para mostrar los mismos datos contra dos escalas x (por ejemplo, metros y pies, o tiempo en segundos y minutos). El mismo consejo de codificación por color aplica — iguala el color del eje a su curva.
import matplotlib.pyplot as plt
import numpy as np
y = np.linspace(0, 10, 50)
fig, ax1 = plt.subplots()
ax1.plot(np.exp(y), y, "g-")
ax1.set_ylabel("y")
ax1.set_xlabel("exp(y)", color="g")
# second axes sharing y, independent x on top
ax2 = ax1.twiny()
ax2.plot(y**2, y, "m-")
ax2.set_xlabel("y^2", color="m")
plt.title("twiny: two x-scales")
plt.show()Gráfico gemelo combinado
Al gemelar ejes, cada uno tiene su propia leyenda. Para mostrar una leyenda combinada única, recoge los manejadores de línea de ambos ejes en una lista y llama a ax1.legend(líneas, etiquetas). Esta es la forma idiomática de mantener una única clave en un gráfico de doble eje para que los lectores identifiquen ambas series a la vez.
import matplotlib.pyplot as plt
import numpy as np
t = np.linspace(0, 5, 100)
temp_c = 20 + 5*np.sin(t) # Celsius
humidity = 60 - 5*t # percent
fig, ax1 = plt.subplots(figsize=(8, 4))
l1, = ax1.plot(t, temp_c, "r-o", label="Temperature (C)")
ax1.set_xlabel("time (s)")
ax1.set_ylabel("Temperature (C)", color="r")
ax1.tick_params(axis="y", labelcolor="r")
ax2 = ax1.twinx()
l2, = ax2.plot(t, humidity, "b-s", label="Humidity (%)")
ax2.set_ylabel("Humidity (%)", color="b")
ax2.tick_params(axis="y", labelcolor="b")
# combine legends from both axes
lines = [l1, l2]
ax1.legend(lines, [l.get_label() for l in lines], loc="upper right")
plt.title("Temperature & Humidity")
plt.show()Despinar ejes gemelos
Los ejes gemelos naturalmente producen un borde superior duplicado. Oculta los spines superiores de ambos ejes para un aspecto más limpio, y colorea los spines izquierdo/derecho para que coincidan con su eje y respectivo. Combinado con etiquetas de marca coloreadas esto señala claramente qué escala pertenece a qué curva sin saturar el gráfico.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
fig, ax1 = plt.subplots()
ax2 = ax1.twinx()
ax1.plot(x, np.sin(x), color="tab:blue")
ax2.plot(x, np.cos(x), color="tab:orange")
# remove the top spine so the two axes don't double-border
ax1.spines["top"].set_visible(False)
ax2.spines["top"].set_visible(False)
# color the spines to match their axes
ax1.spines["left"].set_color("tab:blue")
ax2.spines["right"].set_color("tab:orange")
plt.title("Clean Twin Axes")
plt.show()Gemelo con unidades distintas
A veces no necesitas una segunda serie graficada — solo quieres un segundo eje con unidades convertidas (km/millas, C/F). Crea twiny(), alinea los límites con set_xlim, y luego fija manualmente xticks/xticklabels a los valores convertidos. Esto anota una serie de datos con dos sistemas de unidades.
import matplotlib.pyplot as plt
import numpy as np
km = np.linspace(0, 100, 50)
mile = km * 0.621371
fig, ax1 = plt.subplots()
ax1.plot(km, np.sin(km/10), "tab:purple")
ax1.set_xlabel("distance")
ax1.set_ylabel("signal", color="tab:purple")
ax2 = ax1.twiny()
ax2.set_xlim(ax1.get_xlim()) # align x limits
# relabel the top ticks in miles
new_ticks = np.array([0, 25, 50, 75, 100])
ax2.set_xticks(new_ticks)
ax2.set_xticklabels([f"{m:.0f}" for m in new_ticks*0.621371])
ax2.set_xlabel("miles")
plt.show()Barras de error y áreas rellenas
errorbar
plt.errorbar(x, y, yerr) grafica puntos con barras de error verticales — el estándar para datos experimentales con incertidumbre. fmt es una cadena de formato de plot ('o-' = marcadores + línea). ecolor, elinewidth y capsize estilizan las barras de error. Usa xerr= para errores horizontales, o ambos para incertidumbres 2D.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 10)
y = np.exp(-x)
yerr = 0.1 + 0.1*x # error grows with x
plt.errorbar(x, y, yerr=yerr, fmt="o-", color="tab:blue",
ecolor="gray", elinewidth=1.5, capsize=4,
markersize=6, label="exp(-x) +/- err")
plt.legend()
plt.title("Error Bar Plot")
plt.show()Errores asimétricos
Para incertidumbres asimétricas pasa yerr como un array 2 x N: la fila 0 son los errores inferiores (hacia abajo) y la fila 1 los superiores (hacia arriba). Es común cuando los errores están sesgados (por ejemplo, conteos de Poisson). El mismo patrón aplica a xerr para incertidumbres horizontales asimétricas.
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(5)
y = np.array([2, 3, 5, 4, 6])
# separate lower and upper errors (each a 1-D array)
yerr = [[0.5, 1, 0.8, 0.6, 1.2], # lower
[1.0, 0.8, 1.5, 1.0, 0.7]] # upper
plt.errorbar(x, y, yerr=yerr, fmt="s", color="tab:green",
capsize=5)
plt.title("Asymmetric Error Bars")
plt.show()
# horizontal asymmetric errors work the same way
# xerr = [[...lower...], [...upper...]]fill_between
fill_between(x, y1, y2) sombrea la región entre dos curvas y — perfecto para intervalos de confianza, bandas de error y rangos. where= limita el relleno a donde un array booleano es True (usa interpolate=True si las curvas se cruzan). alpha < 1 mantiene la curva subyacente visible a través de la banda.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
y = np.sin(x)
std = 0.2
plt.plot(x, y, "b-", label="mean")
# shade +/- one standard deviation
plt.fill_between(x, y - std, y + std, color="blue", alpha=0.2,
label="+/- 1 std")
# shade only where a condition holds
plt.fill_between(x, y, 0, where=(y > 0), color="green", alpha=0.2,
label="y > 0")
plt.legend()
plt.show()stackplot
plt.stackplot(x, y1, y2, ...) apila varias series unas sobre otras, mostrando totales y composición a lo largo de una x continua (normalmente el tiempo). A diferencia de las barras apiladas, es para datos continuos. La altura total es la suma de todas las series. Usa colores distintos con alpha para que los límites entre capas queden claros.
import matplotlib.pyplot as plt
import numpy as np
years = np.arange(2010, 2021)
a = np.array([10, 12, 14, 15, 17, 18, 20, 22, 23, 25, 27])
b = np.array([ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
c = np.array([ 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 10])
plt.stackplot(years, a, b, c, labels=["A", "B", "C"],
colors=["#4C72B0", "#55A868", "#C44E52"], alpha=0.8)
plt.legend(loc="upper left")
plt.title("Stacked Area Chart")
plt.xlabel("year")
plt.ylabel("value")
plt.show()fill (polígono)
plt.fill(x, y) cierra y sombrea un polígono arbitrario — útil para resaltar regiones o sombrear bajo una curva. Para sombrear bajo una curva, concatena los valores x con su inverso y los y con ceros. Para múltiples regiones rellenas disjuntas, pasa arrays 2D o llama a fill repetidamente.
import matplotlib.pyplot as plt
import numpy as np
# fill a closed polygon defined by its vertices
x = [0, 1, 1, 0, 0]
y = [0, 0, 1, 1, 0]
plt.fill(x, y, color="tab:cyan", alpha=0.5)
# shade under a curve
xs = np.linspace(0, 2*np.pi, 100)
ys = np.sin(xs)
plt.fill(np.r_[xs, xs[::-1]],
np.r_[ys, np.zeros_like(ys)],
color="tab:orange", alpha=0.3)
plt.title("Filled Polygons")
plt.show()Integración de Seaborn
Introducción a Seaborn
Seaborn es una librería de graficación estadística de alto nivel construida sobre Matplotlib: acepta DataFrames de pandas, maneja agrupación/agregación y usa valores por defecto más bonitos. Cada función de Seaborn devuelve un Axes (o Figure) de Matplotlib, así que puedes seguir personalizando con llamadas plt/ax. Llama a sns.set_theme() una vez para cambiar al estilo de Seaborn.
# install seaborn
pip install seaborn
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
# Seaborn is built ON matplotlib: any sns plot returns an Axes
# and accepts an ax= argument, so you can mix freely.
sns.set_theme() # apply seaborn's default style
tips = sns.load_dataset("tips")
ax = sns.scatterplot(data=tips, x="total_bill", y="tip", hue="time")
ax.set_title("Tips dataset")
plt.show()Estilos de Seaborn
sns.set_style fija el aspecto de los ejes (cuadrícula, fondo), set_context escala fuentes/líneas para el medio de salida ('paper', 'talk', 'poster'), y set_palette fija el ciclo de colores. sns.despine() elimina los spines superior/derecho. Estos se componen en un aspecto por defecto pulido con una o dos líneas.
import seaborn as sns
import matplotlib.pyplot as plt
# five built-in themes: darkgrid, whitegrid, dark, white, ticks
sns.set_style("whitegrid")
sns.set_context("notebook") # paper, notebook, talk, poster
# set the color palette
sns.set_palette("Set2")
import numpy as np
for i in range(4):
plt.plot(np.arange(10), np.arange(10)+i)
plt.title("Seaborn-styled")
plt.show()
# remove the top/right spines (despine) for a clean look
# sns.despine()relplot (relacional)
sns.relplot es la interfaz a nivel de figura para gráficos relacionales: kind='scatter' (por defecto) o 'line'. col/row dividen los datos en subplots (facetas) automáticamente — mucho más fácil que subplots manuales. Devuelve un FacetGrid cuyo .fig y .axes te permiten bajar a Matplotlib para afinar títulos y layout.
import seaborn as sns
import matplotlib.pyplot as plt
tips = sns.load_dataset("tips")
# scatter or line, faceted by a categorical variable
g = sns.relplot(data=tips, x="total_bill", y="tip",
hue="smoker", style="time", col="day",
kind="scatter", height=3, aspect=1.2)
g.fig.suptitle("Tips by day", y=1.03)
plt.show()histplot y kdeplot
sns.histplot es el reemplazo moderno del obsoleto distplot: dibuja histogramas y puede superponer una estimación de densidad de kernel (kde=True). stat='density' normaliza, y common_norm=False mantiene los grupos normalizados independientemente. sns.kdeplot dibuja solo la curva de densidad suave, útil para comparar distribuciones.
import seaborn as sns
import matplotlib.pyplot as plt
tips = sns.load_dataset("tips")
# histogram with an overlaid KDE (density curve)
sns.histplot(data=tips, x="total_bill", bins=20, kde=True,
hue="time", stat="density", common_norm=False)
plt.title("Histogram + KDE")
plt.show()
# standalone KDE
plt.figure()
sns.kdeplot(data=tips, x="total_bill", hue="time", fill=True)
plt.show()heatmap
sns.heatmap dibuja una matriz codificada por color con anotaciones de celda opcionales (annot=True). center=0 con un cmap divergente (coolwarm) hace visualmente distintas las correlaciones positivas/negativas. Envuelve plt.imshow + plt.text + colorbar, ahorrando mucho boilerplate para matrices de correlación y de confusión.
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
# correlation matrix
tips = sns.load_dataset("tips")
num = tips.select_dtypes("number").drop(columns=["size"])
corr = num.corr()
sns.heatmap(corr, annot=True, cmap="coolwarm", center=0,
vmin=-1, vmax=1, square=True,
linewidths=0.5, fmt=".2f")
plt.title("Correlation Heatmap")
plt.show()pairplot y violinplot
sns.pairplot crea una cuadrícula de gráficos de dispersión para cada par de columnas numéricas, coloreados por un tono categórico — la forma más rápida de explorar relaciones en un dataset nuevo. sns.violinplot combina un box plot con una estimación de densidad, mostrando la forma de la distribución por grupo. Ambos son Matplotlib puro por debajo y pueden personalizarse más.
import seaborn as sns
import matplotlib.pyplot as plt
iris = sns.load_dataset("iris")
# scatter matrix: every numeric column vs every other
g = sns.pairplot(iris, hue="species", height=2.5)
g.fig.suptitle("Iris pairplot", y=1.01)
plt.show()
# violin plot: box + kernel density on each side
plt.figure()
sns.violinplot(data=iris, x="species", y="sepal_length",
inner="quartile")
plt.show()Interactivo y animación
Widget Slider
matplotlib.widgets.Slider añade un deslizador interactivo. Crea unos ejes para él (a menudo al pie de la figura vía plt.axes([left, bottom, width, height] en fracción de figura)), conecta un callback a on_changed y actualiza tus datos del gráfico dentro. Llama a fig.canvas.draw_idle() para refrescar. Requiere un backend interactivo (no Agg).
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider
import numpy as np
fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.25)
x = np.linspace(0, 10, 500)
line, = ax.plot(x, np.sin(x))
# axes for the slider
ax_freq = plt.axes([0.2, 0.1, 0.6, 0.03])
slider = Slider(ax_freq, "freq", 0.1, 5.0, valinit=1.0)
def update(val):
line.set_ydata(np.sin(slider.val * x))
fig.canvas.draw_idle()
slider.on_changed(update)
plt.show()Botones
matplotlib.widgets.Button añade un botón clicable. Como el slider necesita sus propios ejes (posicionados en coordenadas fracción de figura). El callback recibe un objeto de evento que normalmente ignoras. Combina varios widgets (sliders, botones, checkboxes) para construir dashboards simples de exploración de datos directamente en Matplotlib.
import matplotlib.pyplot as plt
from matplotlib.widgets import Button
import numpy as np
fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.2)
(ln,) = ax.plot(np.random.rand(10))
ax_btn = plt.axes([0.7, 0.05, 0.2, 0.075])
btn = Button(ax_btn, "Resample")
def reshuffle(event):
ln.set_ydata(np.random.rand(10))
fig.canvas.draw_idle()
btn.on_clicked(reshuffle)
plt.show()CheckButtons
CheckButtons renderiza una lista de checkboxes. El callback recibe el texto de la etiqueta alternada, así que comparas con él para alternar la visibilidad de cada artista. Úsalo para dejar que los espectadores activen y desactiven series. Como con cualquier widget, necesitas un backend interactivo y la ventana debe seguir abierta.
import matplotlib.pyplot as plt
from matplotlib.widgets import CheckButtons
import numpy as np
x = np.linspace(0, 5, 200)
l1, = plt.plot(x, np.sin(x), label="sin")
l2, = plt.plot(x, np.cos(x), label="cos")
plt.subplots_adjust(right=0.8)
rax = plt.axes([0.82, 0.4, 0.15, 0.2])
check = CheckButtons(rax, ["sin", "cos"], [True, True])
def toggle(label):
if label == "sin": l1.set_visible(not l1.get_visible())
if label == "cos": l2.set_visible(not l2.get_visible())
plt.draw()
check.on_clicked(toggle)
plt.show()Cursor y eventos de ratón
mpl_connect vincula eventos (button_press_event, motion_notify_event, key_press_event, scroll_event) a callbacks. El objeto de evento lleva event.xdata/event.ydata (coordenadas de datos) y event.inaxes (qué ejes, o None). Esta es la base de las interacciones personalizadas — miras de tiro cruzado, anotar al hacer clic, herramientas de zoom personalizadas.
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])
def on_click(event):
if event.inaxes != ax:
return
print(f"clicked at x={event.xdata:.2f} y={event.ydata:.2f}")
def on_move(event):
if event.inaxes == ax:
ax.set_title(f"x={event.xdata:.2f}, y={event.ydata:.2f}")
fig.canvas.draw_idle()
fig.canvas.mpl_connect("button_press_event", on_click)
fig.canvas.mpl_connect("motion_notify_event", on_move)
plt.show()Animación (FuncAnimation)
FuncAnimation impulsa una animación llamando repetidamente a update(frame). update debe devolver los artistas cambiados (como tupla) para que blit=True pueda redibujar solo ellos por velocidad. interval es el retardo entre fotogramas en ms. Guardar exige un writer ('ffmpeg' para mp4, 'pillow' para gif). Mantén el objeto de animación (ani) referenciado o el recolector de basura lo elimina y se detiene.
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np
fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 200)
line, = ax.plot(x, np.sin(x))
def update(frame):
line.set_ydata(np.sin(x + frame / 10.0))
return line,
ani = animation.FuncAnimation(fig, update, frames=100,
interval=50, blit=True, repeat=True)
# save to a file (requires ffmpeg or pillow installed)
# ani.save("wave.mp4", writer="ffmpeg")
# ani.save("wave.gif", writer="pillow")
plt.show()Fragmentos de Matplotlib relacionados
Copy-paste ready code for common tasks.
Line Plot
Plot lines with markers, colors, and styles.
Bar Chart
Draw vertical, horizontal, and grouped bars.
Scatter Plot
Visualize relationships with size and color encodings.
Subplots
Arrange multiple axes with subplots and GridSpec.
Labels and Legend
Annotate plots with text, arrows, and legend options.
Styles and Themes
Apply built-in styles and customize rcParams.
Save Figure
Export figures to PNG, PDF, and SVG with DPI control.
3D Plot
Render surfaces and scatter in 3D.
Was this helpful?