Visualización con Matplotlib y Seaborn

Matplotlib es la biblioteca estándar de gráficos para Python, y tanto pandas como seaborn dibujan con ella. Por convención se importa como import matplotlib.pyplot as plt. En un cuaderno de Jupyter, un gráfico aparece debajo de la celda que lo dibuja; en un script, plt.show() muestra las figuras abiertas y, en un script normal, espera hasta que se cierren sus ventanas.

Una figura es el lienzo completo: la imagen que se muestra o se guarda. Un área de trazado es una zona de la figura donde se representan datos, con sus propios datos, título, etiquetas de los ejes y límites; una figura puede contener varias. Un eje es una de las rectas numéricas de un área de trazado, el eje x o el eje y, con sus marcas y etiquetas de graduación. Cada elemento visible, como una línea, un marcador, un texto o una barra, se llama objeto gráfico.

fig, ax = plt.subplots() crea una figura con un área de trazado y devuelve ambos objetos. figsize=(width, height) establece el tamaño de la figura en pulgadas. El valor predeterminado es 6,4 × 4,8 pulgadas a 100 puntos por pulgada, por lo que una figura predeterminada ocupa 640 × 480 píxeles en pantalla; plt.subplots(figsize=(8, 4)) crea una figura más ancha y baja.

Matplotlib ofrece dos estilos. En el estilo orientado a objetos se llaman métodos sobre objetos explícitos: ax.plot(...), ax.set_title(...). En el estilo pyplot, funciones como plt.plot(...) y plt.title(...) actúan sobre el área de trazado «actual», normalmente la última creada. Ambos dibujan los mismos gráficos; el estilo orientado a objetos resulta más claro en cuanto una figura tiene más de un área de trazado o el código de representación se incluye en una función, por lo que este curso lo utiliza.

Los dos estilos utilizan nombres distintos para los mismos ajustes: plt.title, plt.xlabel y plt.xlim corresponden a ax.set_title, ax.set_xlabel y ax.set_xlim. Un error frecuente es ax.title("Rainfall"): en un área de trazado, title es un atributo que contiene un objeto de texto, por lo que llamarlo produce TypeError: 'Text' object is not callable. Utiliza ax.set_title("Rainfall").

months = [1, 2, 3, 4, 5, 6]; temp_c = [3, 5, 9, 13, 17, 20], seguido de

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(months, temp_c)
ax.set_title("Mean monthly temperature")
ax.set_xlabel("Month")
ax.set_ylabel("Temperature (°C)")

.

Las llamadas de dibujo añaden elementos a un área de trazado; no sustituyen lo que ya hay. Una segunda llamada a ax.plot(...) sobre el mismo ax añade una segunda línea al mismo gráfico. Para obtener un gráfico separado, crea una figura nueva con otra llamada a plt.subplots() o dibuja en otra área de trazado de una figura con varios paneles.

pyplot mantiene abiertas todas las figuras que ha creado hasta que se cierran con plt.close(fig) o plt.close("all"). Las figuras abiertas consumen memoria y, cuando hay más de 20 abiertas, Matplotlib muestra una advertencia. El código que crea figuras en un bucle debe cerrar cada figura después de guardarla.

ax.plot(x, y) dibuja marcadores o segmentos rectos que unen los puntos en el orden en que se proporcionan. Un gráfico de líneas es adecuado para una magnitud medida a lo largo de una variable ordenada, como el tiempo o la distancia. Con un argumento, ax.plot(y), los valores predeterminados de x son 0, 1, 2, ….

Como los puntos se unen en el orden proporcionado, los valores de x sin ordenar producen un zigzag que va y viene por el gráfico. Para x = [3, 1, 2], la línea va de x = 3 hacia atrás hasta x = 1 y luego hacia adelante hasta x = 2. Ordena primero los datos por x, por ejemplo con df.sort_values("x").

Argumentos de estilo: color (un nombre como "black" o "tab:orange", o un código hexadecimal como "#1f77b4"), linestyle ("-" continua, "--" discontinua, ":" punteada, "-." de raya y punto), linewidth, marker ("o" círculo, "s" cuadrado, "^" triángulo) y markersize. Una cadena de formato breve combina el marcador y el estilo de línea: ax.plot(x, y, "o--") dibuja círculos unidos por una línea discontinua. Sin un color, cada línea nueva toma el siguiente color del ciclo predeterminado, que comienza con "tab:blue" y "tab:orange".

Asigna un label a cada línea y llama a ax.legend() para mostrar una leyenda:

ax.plot(months, north, marker="o", label="North")
ax.plot(months, coast, linestyle="--", label="Coast")
ax.legend()

. Si ningún objeto gráfico tiene etiqueta, ax.legend() no dibuja nada y Matplotlib advierte que no encontró objetos gráficos con etiquetas.

ax.scatter(x, y) dibuja un marcador sin conectar por cada observación y es adecuado para representar la relación entre dos variables numéricas. Ejemplo: temperatura diaria [12, 15, 18, 21, 24, 27, 30, 22] °C y alquileres de bicicletas [180, 220, 260, 310, 330, 360, 340, 250]; ax.scatter(temp_c, rentals) muestra que los alquileres aumentan en general con la temperatura, y la correlación entre las dos listas es de aproximadamente 0,92.

En ax.scatter, s establece el área de cada marcador en puntos cuadrados; el valor predeterminado es 36, el área de un marcador de 6 puntos de ancho. Al duplicar s se duplica el área, por lo que el ancho del marcador solo aumenta por un factor de aproximadamente 1,4. s puede ser un número o un valor por punto, lo que permite representar una tercera variable mediante el tamaño de los marcadores.

c da color a los puntos: un color para todos o un número por punto que se asigna mediante un mapa de colores como cmap="viridis". Conserva el objeto devuelto y añade una barra de colores: sc = ax.scatter(temp_c, rentals, c=rain_mm, cmap="viridis"); fig.colorbar(sc, ax=ax, label="Rain (mm)").

Cuando se superponen muchos puntos, las zonas densas se convierten en manchas sólidas que ocultan cuántos puntos contienen. Reduce la opacidad con alpha=0.3, utiliza marcadores más pequeños o muestra la densidad, por ejemplo con un gráfico de agrupación en celdas hexagonales (df.plot.hexbin) o un histograma bidimensional.

ax.plot(x, y, "o"), con un marcador y sin línea, también dibuja puntos y es más rápido para un número muy grande de puntos porque todos los marcadores comparten tamaño y color. Utiliza ax.scatter cuando el tamaño o el color deban variar de un punto a otro.

ax.bar(categories, heights) dibuja una barra vertical por categoría; ax.barh(categories, widths) dibuja barras horizontales, que dejan espacio para nombres de categorías largos. Cuando las categorías son cadenas de texto, Matplotlib las sitúa a distancias iguales en el orden proporcionado y las utiliza como etiquetas de graduación. Cuando son números, las barras se sitúan en esas posiciones numéricas sobre un eje numérico ordinario.

De forma predeterminada, las barras parten de una línea de base de 0, por lo que su longitud muestra su valor. El argumento width se mide en unidades del eje x y su valor predeterminado es 0,8. Las categorías de texto se sitúan a una unidad de distancia, por lo que el valor predeterminado deja un espacio de 0,2 entre barras, y width=1 hace que las barras vecinas se toquen.

Se preguntó a 200 personas cómo se desplazan habitualmente: coche 84, autobús 52, bicicleta 38, a pie 26. ax.barh(["Car", "Bus", "Bike", "Walk"], [84, 52, 38, 26]) dibuja cuatro barras horizontales. Las proporciones son 42 %, 26 %, 19 % y 13 %, que suman 100 %.

ax.barh sitúa la primera categoría en la parte inferior del eje, porque el eje y crece hacia arriba. Para leer una lista ordenada desde arriba, como en el ejemplo de los desplazamientos, llama a ax.invert_yaxis() o invierte tanto las categorías como sus valores antes de representarlos, de modo que cada valor permanezca con su categoría.

Las barras agrupadas sitúan varias series una junto a otra en cada categoría. Utiliza posiciones numéricas y desplaza cada serie la mitad del ancho de una barra:

x = np.arange(3)
ax.bar(x - 0.2, north, width=0.4, label="North")
ax.bar(x + 0.2, coast, width=0.4, label="Coast")
ax.set_xticks(x, labels=["Jan", "Feb", "Mar"])
ax.legend()

. Las barras de North están en −0,2, 0,8 y 1,8, y las de Coast en 0,2, 1,2 y 2,2, centradas en cada marca de graduación.

Las barras apiladas dibujan una segunda serie encima de la primera con bottom=: ax.bar(days, car); ax.bar(days, bus, bottom=car). Si un día hay 40 viajes en coche y 25 en autobús, el segmento del autobús va de 40 a 65 y la altura total de la barra es 65.

bars = ax.bar(...) devuelve un contenedor de barras; ax.bar_label(bars) escribe cada valor al final de su barra. fmt controla el texto: fmt="%.1f" escribe 3,14 como «3.1», y fmt="{:.0f} km" lo escribe como «3 km».

Matplotlib dibuja las barras en el orden de los datos, no por tamaño. Para obtener un gráfico ordenado por valor, ordena primero los valores, por ejemplo con sorted() sobre pares o con sort_values() en pandas. El argumento yerr= añade barras de error de una longitud determinada a cada barra, y ax.errorbar(x, y, yerr=...) hace lo mismo para puntos.

Un gráfico de barras compara valores de categorías separadas, por lo que sus barras están separadas por espacios. En cambio, un histograma muestra cómo se distribuye una variable numérica en intervalos contiguos y sus barras se tocan. Representar las mediciones con una barra por fila de datos produce un gráfico de barras de valores sin resumir, no un histograma.

Establece el texto con ax.set_title("..."), ax.set_xlabel("...") y ax.set_ylabel("..."), o con una sola llamada: ax.set(title="Monthly rainfall", xlabel="Month", ylabel="Rainfall (mm)"). Pon la unidad en la etiqueta del eje, por ejemplo «Precipitación (mm)» o «Distancia (km)», para que cada valor de las marcas de graduación tenga significado.

Matplotlib elige los límites de los ejes a partir de los datos y añade un pequeño margen. Establécelos tú con ax.set_xlim(1, 12) y ax.set_ylim(0, 120), o fija solo un extremo con ax.set_ylim(bottom=0). ax.set(xlim=(1, 12), ylim=(0, 120)) hace lo mismo en una sola llamada.

ax.set_xticks([1, 4, 7, 10]) elige las posiciones de las marcas de graduación, y ax.set_xticks([1, 2, 3], labels=["Jan", "Feb", "Mar"]) también sustituye sus etiquetas. Gira las etiquetas amontonadas con ax.tick_params(axis="x", labelrotation=45). Los formateadores de etiquetas de graduación cambian cómo se escriben los valores: ax.yaxis.set_major_formatter(PercentFormatter(xmax=1, decimals=0)), con PercentFormatter importado de matplotlib.ticker, etiqueta el valor 0,25 como «25%».

ax.set_yscale("log") establece una escala logarítmica en el eje y, donde distancias iguales representan razones iguales: el paso de 10 a 100 tiene la misma longitud que el paso de 100 a 1000. Es adecuada para valores que abarcan varios órdenes de magnitud, como las poblaciones de las ciudades. Un eje logarítmico no puede mostrar el cero ni valores negativos.

ax.legend() coloca la leyenda donde cubre menos puntos (loc="best", el valor predeterminado para la leyenda de un área de trazado). Elige una posición con loc="upper left", añade un encabezado con title="Station" y distribuye las entradas en columnas con ncols=2. ax.legend(bbox_to_anchor=(1.02, 1), loc="upper left") coloca la leyenda justo fuera del borde derecho del área de trazado.

ax.grid(True, alpha=0.3) añade líneas de cuadrícula tenues en las marcas de graduación; ax.grid(axis="y") dibuja solo las horizontales, lo que facilita la lectura de las alturas de las barras.

Las hojas de estilos cambian el aspecto predeterminado de todos los gráficos posteriores: plt.style.use("ggplot"). plt.style.available enumera los estilos instalados; los estilos similares a seaborn incluidos con Matplotlib se llaman, por ejemplo, "seaborn-v0_8-whitegrid". Para aplicar un estilo solo a un bloque de código, utiliza with plt.style.context("ggplot"):.

Los ajustes predeterminados individuales se encuentran en plt.rcParams, por ejemplo plt.rcParams["font.size"] = 12 o plt.rcParams["figure.figsize"] = (8, 4). Se aplican a las figuras creadas después, y plt.rcdefaults() restaura los valores predeterminados de Matplotlib.

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot([1, 2, 3, 4], [62, 48, 55, 40], marker="o", label="North")
ax.set(title="Monthly rainfall, January to April", xlabel="Month", ylabel="Rainfall (mm)", ylim=(0, 70))
ax.set_xticks([1, 2, 3, 4], labels=["Jan", "Feb", "Mar", "Apr"])
ax.legend()
ax.grid(axis="y", alpha=0.3)

.

En una figura con varias áreas de trazado, las funciones de pyplot como plt.title o plt.xlabel solo modifican el área actual, normalmente la última creada, por lo que un título puede aparecer en el panel equivocado. Llamar a los métodos del área de trazado deseada, como axes[0].set_title(...), evita este problema.

Crea la tabla de precipitaciones en formato ancho con una columna por estación:

import pandas as pd
wide = pd.DataFrame({
    "North": [62, 48, 55, 40],
    "Coast": [110, 95, 80, 60],
    "Valley": [20, 15, 30, 45]
}, index=pd.Index(["Jan", "Feb", "Mar", "Apr"], name="month"))

Todas las Series y todos los DataFrames de pandas tienen un método .plot que dibuja con Matplotlib y devuelve el área de trazado de Matplotlib en la que dibujó. df.plot(kind="bar") y df.plot.bar() son la misma llamada. Los tipos son "line" (el predeterminado), "bar", "barh", "hist", "box", "kde" o "density", "area", "pie", "scatter" y "hexbin".

De forma predeterminada, el índice pasa a ser el eje x y cada columna numérica se convierte en una línea, con una leyenda creada a partir de los nombres de las columnas. Una Series representa sus valores frente a su índice. Para elegir columnas, pasa x="month" y y="rain_mm", o una lista como y=["North", "Coast"].

Una tabla wide con el índice Jan, Feb, Mar, Apr y las columnas North [62, 48, 55, 40], Coast [110, 95, 80, 60] y Valley [20, 15, 30, 45], todos en milímetros de precipitación. ax = wide.plot(marker="o", figsize=(8, 4), title="Monthly rainfall"); ax.set_ylabel("Rainfall (mm)") dibuja tres líneas etiquetadas en un área de trazado y luego establece la etiqueta del eje y con un método ordinario de Matplotlib.

Argumentos habituales de .plot: title, xlabel, ylabel, xlim, ylim, figsize, color, legend=False, rot (rotación de las etiquetas de graduación en grados), grid=True y logy=True. ax= dibuja en un área de trazado existente, por ejemplo un panel de plt.subplots(1, 2), en lugar de hacerlo en una figura nueva.

subplots=True dibuja cada columna en su propia área de trazado y devuelve un arreglo de NumPy de áreas de trazado en lugar de una sola; layout=(2, 2) las organiza en una cuadrícula y sharey=True les asigna una escala y común. Para la tabla de tres estaciones, wide.plot(subplots=True, layout=(1, 3), sharey=True) produce un panel por estación.

Los diagramas de dispersión y los gráficos de celdas hexagonales solo existen para DataFrames y necesitan tanto x como y: days.plot.scatter(x="temp_c", y="rentals", c="rain_mm", colormap="viridis") colorea los puntos según la precipitación. Una Series no tiene gráfico de dispersión, por lo que s.plot.scatter() produce un error. df.plot.hist(bins=5) y df.plot.box() producen un histograma y un diagrama de caja y bigotes de cada columna numérica.

s.plot.pie() dibuja un sector por valor, cuyo tamaño depende de su proporción del total. Como los gráficos circulares necesitan una Series de partes no negativas de un mismo total, una columna de recuentos como s.value_counts() es una entrada habitual.

Los gráficos de barras de pandas tratan el índice como categorías y colocan las barras en las posiciones 0, 1, 2, …, sean cuales sean los valores del índice. Los gráficos de líneas utilizan los valores reales del índice cuando son números o fechas. Por tanto, una línea y unas barras de pandas dibujadas en la misma área de trazado solo se alinean cuando los valores x de la línea coinciden con las posiciones de las barras, como ocurre con un índice predeterminado 0, 1, 2, …; para años como 2020 a 2023, la línea queda muy a la derecha de las barras. Representa ambos con las mismas posiciones al combinarlos.

Con un DatetimeIndex, .plot() coloca las fechas en el eje x y las etiqueta automáticamente. Los datos diarios suelen resultar más claros después de un remuestreo temporal, por ejemplo a medias mensuales con s.resample("MS").mean().plot().

.plot solo representa columnas numéricas. Si los números se leyeron como texto, por ejemplo porque una columna contiene «12 mm», la columna se omite y, cuando no quedan datos numéricos, pandas produce TypeError: no numeric data to plot. Convierte primero la columna, por ejemplo con pd.to_numeric(...).

Un gráfico representa los valores que hay en la tabla, así que resúmelos primero. Ejemplo: una tabla en formato largo rain con 12 filas, una por estación y mes, y las columnas month, station y rain_mm. rain.groupby("station")["rain_mm"].mean() da una media por estación: Coast 86,25 mm, North 51,25 mm y Valley 27,5 mm. Al añadir .plot.bar() se dibujan tres barras.

Representar por error las filas sin resumir muestra mediciones individuales en lugar de las medias solicitadas: rain.plot.bar(x="station", y="rain_mm") dibuja 12 barras con nombres de estaciones repetidos en lugar de tres medias.

Ordena antes de representar para obtener barras ordenadas por valor: means.sort_values(ascending=False).plot.bar() coloca la media mayor a la izquierda. Para un gráfico horizontal, means.sort_values().plot.barh() coloca la mayor arriba, porque el primer valor se dibuja abajo.

s.value_counts() cuenta cuántas veces aparece cada categoría y muestra los recuentos de mayor a menor frecuencia. Para los medios de transporte «autobús», «coche», «autobús», «bicicleta», «autobús», «coche» da autobús 3, coche 2, bicicleta 1, listo para .plot.bar(). Utiliza .sort_index() o .reindex([...]) cuando las categorías tengan un orden natural, como los días de la semana.

Un DataFrame en formato ancho, con una columna por serie, produce en pandas una línea o un color de barra por columna. Convierte una tabla en formato largo con rain.pivot(index="month", columns="station", values="rain_mm"). Cuando algún par de índice y columna aparece más de una vez, pivot produce un error; utiliza en su lugar pivot_table(..., aggfunc="mean") o groupby(["month", "station"])["rain_mm"].mean().unstack().

pivot y pivot_table ordenan el nuevo índice, por lo que los meses expresados como cadenas aparecen en orden alfabético, Apr, Feb, Jan, Mar, y un gráfico de líneas recorre entonces los meses en un orden incorrecto. Restablece el orden real con wide.reindex(["Jan", "Feb", "Mar", "Apr"]), o almacena el mes como una variable categórica ordenada o como un número de mes antes de convertir a formato ancho.

En una tabla en formato ancho, wide.plot.bar() dibuja barras agrupadas, un grupo por etiqueta del índice y un color por columna, mientras que wide.plot.bar(stacked=True) apila las columnas. La transpuesta wide.T.plot.bar() intercambia los papeles: un grupo por estación y un color por mes.

Para obtener las proporciones dentro de cada grupo, normaliza una tabla de contingencia: pd.crosstab(trips["region"], trips["mode"], normalize="index") divide cada recuento entre el total de su fila, de modo que cada fila suma 1. Si la región N tiene dos viajes en coche y uno en autobús, su fila contiene coche 0,67 y autobús 0,33 (redondeados). .plot.bar(stacked=True) dibuja entonces barras de igual altura total que muestran la composición de cada región.

seaborn funciona mejor con datos en formato largo y ordenado: una fila por observación y una columna por variable. wide.reset_index().melt(id_vars="month", var_name="station", value_name="rain_mm") convierte la tabla ancha de 4 × 3 de nuevo en 12 filas con tres columnas, de modo que station puede utilizarse para el color o las facetas.

seaborn es una biblioteca de gráficos construida sobre Matplotlib que trabaja directamente con DataFrames de pandas y calcula por sí misma resúmenes estadísticos habituales. Por convención se importa como import seaborn as sns. Una llamada típica indica la tabla y sus columnas: sns.scatterplot(data=days, x="temp_c", y="rentals").

Además de x e y, las columnas pueden asociarse con otras características mediante correspondencias semánticas: hue establece el color, style el marcador o el patrón de líneas discontinuas, y size el tamaño del marcador o el ancho de la línea. seaborn elige los colores y crea la leyenda por sí mismo. Una columna categórica para hue recibe colores distintos; una numérica recibe un degradado.

Cada correspondencia necesita una columna en formato largo. Con la tabla de precipitaciones en formato largo, sns.lineplot(data=rain, x="month", y="rain_mm", hue="station", marker="o") dibuja una línea de color por estación con una leyenda. Si hue indica una columna que no está en la tabla, seaborn produce un ValueError que señala que no pudo interpretar el valor.

Cuando x contiene cadenas, seaborn coloca las categorías en el orden en que aparecen por primera vez en los datos, de modo que los meses almacenados como «Jan», «Feb», «Mar» en ese orden de filas conservan el orden del calendario. Las funciones categóricas, como barplot, boxplot y countplot, aceptan order=["Mon", "Tue", "Wed"] para establecer el orden de las categorías, y hue_order establece el orden de los grupos codificados por color en todas las funciones que tienen hue. lineplot no tiene argumento order: para fijar ahí el orden de los nombres de los meses, convierte la columna x en una variable categórica ordenada, por ejemplo pd.Categorical(rain["month"], categories=["Jan", "Feb", "Mar", "Apr"], ordered=True).

Las funciones a nivel de área de trazado, como scatterplot, lineplot, histplot, boxplot, barplot y heatmap, dibujan en un área de trazado de Matplotlib, aceptan ax= para elegirla y la devuelven. Las funciones a nivel de figura, relplot, displot, catplot y lmplot, crean su propia figura, pueden dividirla en paneles con col y row, y devuelven un objeto FacetGrid de seaborn.

Las funciones a nivel de figura establecen el tamaño por panel: height es la altura de cada panel en pulgadas y aspect su relación entre ancho y alto, por lo que cada panel tiene height × aspect pulgadas de ancho; los valores predeterminados son 5 y 1. Como crean su propia figura, no pueden dibujar en un área de trazado existente: relplot, displot y catplot muestran una advertencia e ignoran ax=, y lmplot lo rechaza con un TypeError. Sitúan la leyenda fuera de los paneles.

sns.set_theme() cambia todos los gráficos posteriores, incluidos los de Matplotlib sin seaborn, al aspecto de seaborn: el estilo «darkgrid», el contexto «notebook» y la paleta predeterminada de seaborn. style puede ser «darkgrid», «whitegrid», «dark», «white» o «ticks»; context puede ser «paper», «notebook», «talk» o «poster» y ajusta la escala de fuentes y líneas, por ejemplo de una fuente base de 12 puntos para «notebook» a 18 puntos para «talk».

palette elige los colores de hue, por ejemplo palette="colorblind", "Set2" o "viridis". En seaborn 0.13, pasar palette sin hue está en desuso; para colorear las barras por categoría, asigna a hue la misma columna que a x y añade legend=False: sns.barplot(data=rain, x="station", y="rain_mm", hue="station", legend=False).

El resultado se puede completar con Matplotlib:

ax = sns.scatterplot(...)
ax.set(xlabel="Temperature (°C)", ylabel="Rentals per day", title="Rentals and temperature")

. Para un resultado a nivel de figura, utiliza los métodos de la cuadrícula, como g.set_axis_labels("Temperature (°C)", "Rentals per day"), y g.figure.suptitle("...") para un título general.

sns.scatterplot(data=days, x="temp_c", y="rentals", hue="weekday", size="rain_mm") dibuja un punto por fila, con color y tamaño determinados por otras columnas. Combinar hue y style con la misma columna da a cada grupo un color y un marcador distintos, que siguen siendo distinguibles en escala de grises.

sns.lineplot agrega de forma predeterminada: cuando varias filas comparten un valor de x, dibuja la línea pasando por la media de sus valores de y y sombrea una banda para el intervalo de confianza del 95 % de esa media, calculado mediante remuestreo bootstrap. Ejemplo resuelto: para x = 1 los valores de y son 10, 12 y 14; para x = 2 son 20, 21 y 25; la línea pasa por 12 y 22.

La banda predeterminada muestra la incertidumbre de cada media, no el rango de los datos. errorbar="sd" sombrea en su lugar una desviación estándar por encima y por debajo de la media, errorbar=None elimina la banda y estimator=None (junto con units=) dibuja cada serie individual sin promediar. Con una fila por valor de x no hay nada que promediar ni se muestra una banda.

sns.regplot(data=days, x="temp_c", y="rentals") dibuja un diagrama de dispersión con una recta de mínimos cuadrados y una banda de confianza sombreada del 95 % para esa recta; order=2 ajusta en su lugar una curva cuadrática. sns.lmplot hace lo mismo como función a nivel de figura, por lo que también puede dividir los datos por hue, col o row.

Una línea de ajuste resume los datos con el modelo que elegiste. Se puede dibujar una recta sobre datos curvos, así que observa los puntos alrededor de la línea antes de confiar en ella. Una tendencia fuerte muestra que las variables están asociadas en estos datos, sin establecer una causa.

sns.pairplot(df) dibuja una cuadrícula con un diagrama de dispersión para cada par de columnas numéricas y la distribución de cada columna en la diagonal: histogramas de forma predeterminada y curvas de densidad cuando se establece hue. Cuatro columnas numéricas producen una cuadrícula de 4 × 4 con 16 paneles. corner=True conserva solo el triángulo inferior y vars=[...] limita las columnas. Devuelve un PairGrid.

sns.jointplot(data=days, x="temp_c", y="rentals") dibuja un diagrama de dispersión con el histograma de cada variable en sus bordes; kind="hex" sustituye los puntos por celdas hexagonales, lo que ayuda con conjuntos de datos grandes.

sns.relplot(..., kind="scatter") y sns.relplot(..., kind="line") son las versiones a nivel de figura de scatterplot y lineplot; el tipo predeterminado es el de dispersión. Utilízalas cuando la misma relación deba mostrarse en paneles separados para cada grupo.

sns.regplot(data=days, x="temp_c", y="rentals") muestra que los alquileres aumentan de 180 a 12 °C hasta aproximadamente 350 en los días más cálidos, con una correlación de aproximadamente 0,92. El día de 30 °C tiene menos alquileres (340) que el de 27 °C (360), por lo que los puntos se nivelan en la parte superior; se puede comparar un ajuste cuadrático (order=2) con la recta.

Las funciones categóricas de seaborn sitúan cada categoría en las posiciones 0, 1, 2, … del eje categórico. Incluso los números se tratan como etiquetas: los años 2020, 2021 y 2023 se dibujan a distancias iguales, sin dejar un espacio para 2022. native_scale=True conserva un eje numérico con las distancias reales.

sns.barplot(data=rain, x="station", y="rain_mm") dibuja una barra por estación cuya altura es la media de sus filas, con una barra de error para el intervalo de confianza del 95 % de esa media. Con la tabla de precipitaciones, las barras son Coast 86,25, North 51,25 y Valley 27,5 mm. estimator="median" o estimator="sum" cambia el resumen; errorbar="sd" o errorbar=None cambia o elimina las barras de error.

sns.countplot(data=trips, x="mode") cuenta las filas de cada categoría y no necesita una columna numérica; sns.barplot resume una columna numérica. Utiliza countplot para «cuántos» y barplot para «cuánto en promedio».

sns.pointplot muestra la media de cada grupo como un punto con una barra de error y une con una línea los puntos de cada grupo definido por hue. Facilita la comparación de cambios entre categorías, por ejemplo la precipitación media de tres estaciones en cada uno de cuatro meses.

Una barra de medias oculta la dispersión y el número de observaciones: una media de 3 filas parece tan sólida como una media de 300. A menudo es mejor mostrar los datos: sns.stripplot dibuja cada observación como un punto con un pequeño desplazamiento aleatorio, y sns.swarmplot organiza los puntos para que no se superpongan. Se puede dibujar un diagrama de puntos por categorías sobre un diagrama de caja y bigotes o un gráfico de barras en la misma área de trazado.

Con hue, los diagramas de barras, caja y violín sitúan de forma predeterminada los grupos uno junto a otro dentro de cada categoría mediante un desplazamiento lateral. Los diagramas de puntos, puntos por categorías y enjambre dibujan los grupos en la misma posición salvo que se establezca dodge=True, por lo que sus puntos pueden superponerse. Establece el orden de las categorías con order=[...] y el de los grupos con hue_order=[...].

La orientación depende de los datos: coloca las categorías en el eje y y los números en el eje x, sns.barplot(data=rain, x="rain_mm", y="station"), para obtener barras horizontales con etiquetas largas legibles. orient="y" (o "h") lo indica de forma explícita.

sns.catplot es la función a nivel de figura para todos los gráficos categóricos. Su kind puede ser «strip» (el predeterminado), «swarm», «box», «violin», «boxen», «point», «bar» o «count», y col o row divide el gráfico en paneles.

Un histograma divide el rango de una variable numérica en intervalos contiguos llamados intervalos de clase y dibuja sobre cada uno una barra cuya altura es el número de observaciones que contiene. Muestra la forma de una distribución: dónde se centran los valores, cuánto se dispersan, si son asimétricos y si hay huecos o valores inusuales.

counts, edges, patches = ax.hist(data, bins=5) dibuja el histograma y devuelve el recuento de cada intervalo de clase y sus límites. Si se proporciona un entero, los intervalos tienen la misma amplitud desde el mínimo hasta el máximo; el valor predeterminado es 10 intervalos. Cada intervalo incluye su límite izquierdo y excluye el derecho, salvo el último, que incluye ambos.

20 tiempos de desplazamiento en minutos: 12, 15, 18, 20, 22, 22, 25, 27, 28, 30, 31, 33, 35, 38, 40, 42, 45, 50, 55, 62. Con bins=5 los límites son 12, 22, 32, 42, 52 y 62, y los recuentos son 4, 7, 4, 3 y 2. El valor 22 cae en el segundo intervalo porque los intervalos excluyen su límite derecho, y 62 se cuenta en el último porque este lo incluye.

El número y la posición de los intervalos cambian la imagen. Los mismos 20 tiempos con límites [10, 20, 30, 40, 50, 60, 70] dan los recuentos 3, 6, 5, 3, 2 y 1. Demasiados pocos intervalos ocultan la forma; demasiados producen un gráfico irregular con muchos intervalos casi vacíos. Prueba varios ajustes y prefiere límites redondos que los lectores puedan interpretar, como pasos de 10 minutos.

density=True en Matplotlib, o stat="density" en seaborn, escala las barras para que su área total sea 1: cada altura es recuento ÷ (n × amplitud del intervalo). Para los datos de desplazamientos con cinco intervalos de 10 minutos, la altura de la segunda barra es 7 ÷ (20 × 10) = 0,035 por minuto. Una altura de densidad no es una probabilidad; altura × amplitud del intervalo es la proporción de observaciones del intervalo.

sns.histplot(data=commutes, x="minutes") dibuja un histograma con seaborn; bins y binwidth controlan los intervalos. stat elige la altura: «count» (predeterminado), «probability» o «proportion» (las alturas suman 1), «percent» (las alturas suman 100) y «density» (área 1). Para los cinco intervalos de desplazamiento, «probability» da 0,2, 0,35, 0,2, 0,15 y 0,1.

Para comparar grupos, sns.histplot(data=commutes, x="minutes", hue="mode") superpone un histograma por grupo; multiple="stack" los apila, multiple="dodge" los coloca uno junto a otro y element="step" dibuja contornos cuya superposición se lee con mayor facilidad. Los grupos de distintos tamaños se comparan de forma equitativa con stat="density", common_norm=False, que escala cada grupo a un área de 1.

Una estimación de densidad por núcleos es una curva suave que estima la forma de la distribución; el área bajo ella es 1. sns.kdeplot(data=commutes, x="minutes") la dibuja y sns.histplot(..., kde=True) la añade a un histograma. Un bw_adjust superior a 1 hace que la curva sea más suave; inferior a 1, más detallada.

Una curva KDE se extiende más allá de los valores mínimo y máximo, por lo que puede mostrar densidad por debajo de 0 minutos para tiempos que no pueden ser negativos. cut=0 detiene la curva en los límites de los datos. En muestras pequeñas, la curva puede sugerir una forma que los datos no respaldan.

En pandas, commutes["minutes"].plot.hist(bins=5, edgecolor="white") dibuja un histograma (10 intervalos de forma predeterminada), y df.hist() dibuja un histograma por columna numérica en una cuadrícula. En seaborn, sns.displot es la versión a nivel de figura: kind="hist" (predeterminado), kind="kde" o kind="ecdf", donde una ECDF muestra para cada valor la proporción de observaciones menores o iguales a él.

Un diagrama de caja y bigotes resume una distribución: la caja va del primer cuartil (Q1) al tercer cuartil (Q3), una línea en su interior marca la mediana, los bigotes se extienden hacia los valores típicos más pequeño y más grande, y los puntos más allá de los bigotes se dibujan individualmente como posibles valores atípicos. El rango intercuartílico IQR = Q3 − Q1 es la longitud de la caja y abarca la mitad central de los datos.

De forma predeterminada, Matplotlib, pandas y seaborn utilizan whis=1.5: los límites de detección de valores atípicos son Q1 − 1,5 × IQR y Q3 + 1,5 × IQR. Cada bigote termina en el valor observado más extremo dentro de su límite, no en el propio límite, y cada valor fuera de los límites se dibuja como un punto separado.

11 tiempos de entrega en minutos: 14, 16, 17, 18, 19, 20, 21, 22, 24, 25, 41. Matplotlib calcula Q1 = 17,5, mediana = 20 y Q3 = 23, por lo que IQR = 5,5. Los límites son 17,5 − 8,25 = 9,25 y 23 + 8,25 = 31,25. El bigote inferior termina en 14, el superior en 25, y 41 se dibuja como un punto atípico.

Los cuartiles dependen del método. Las bibliotecas de gráficos utilizan interpolación lineal entre los valores ordenados (el método predeterminado de NumPy y pandas), que da 17,5 y 23 en el ejemplo anterior. El método manual de tomar las medianas de las mitades inferior y superior sin la mediana general da Q1 = 17 y Q3 = 24 para los mismos datos. Ambos son válidos; las pequeñas diferencias entre un cálculo manual y un gráfico se deben a esto.

Dibuja el resumen con la biblioteca que estés utilizando: ax.boxplot([north, coast], tick_labels=["North", "Coast"]) en Matplotlib (el argumento se llamaba labels antes de la versión 3.9); rain.boxplot(column="rain_mm", by="station") en pandas, que también añade el título general «Boxplot grouped by station»; sns.boxplot(data=rain, x="station", y="rain_mm") en seaborn, con hue para una segunda agrupación. whis=(0, 100) extiende los bigotes hasta el mínimo y el máximo, y showfliers=False oculta los puntos atípicos.

Los diagramas de caja y bigotes colocados uno junto a otro permiten comparar grupos de un vistazo: compara las medianas, las longitudes de las cajas (la dispersión de la mitad central) y la superposición de las cajas. Una mediana cercana a un extremo de la caja, o un bigote mucho más largo que el otro, indica una distribución asimétrica.

Una caja muestra solo cinco números y los valores atípicos. No muestra el número de observaciones, y distribuciones de formas muy distintas pueden tener la misma caja: una distribución con dos picos separados y otra con un solo pico pueden compartir Q1, la mediana y Q3. Superponer los puntos, sns.stripplot(data=rain, x="station", y="rain_mm", color="black", alpha=0.5), o utilizar un diagrama de violín permite verlo.

sns.violinplot(data=rain, x="station", y="rain_mm") dibuja una curva de densidad reflejada para cada grupo con un pequeño diagrama de caja y bigotes dentro (inner="box", el valor predeterminado); inner="quart" marca en su lugar los cuartiles con líneas. Con un hue de dos niveles, split=True coloca un grupo a cada lado del violín. Al igual que una KDE, el violín puede extenderse más allá de los datos; cut=0 lo detiene en el mínimo y el máximo observados.

Un punto señalado por la regla de 1,5 × IQR es inusual con respecto al resto de los datos, una razón para investigar el valor. Compruébalo: puede ser un error de entrada de datos o un valor real e importante, como una entrega retrasada por el cierre de una carretera. Eliminar puntos solo porque el gráfico los señala distorsiona el análisis.

Un mapa de calor muestra una tabla de números como una cuadrícula de celdas coloreadas: las filas y las columnas son dos categorías (o variables agrupadas en intervalos), y el color de cada celda representa su valor. Es adecuado para observar patrones en tablas de doble entrada, como visitantes por día y franja horaria, y en matrices de correlaciones.

sns.heatmap(table) toma una tabla en formato ancho, utiliza su índice como etiquetas de fila y sus columnas como etiquetas de columna, y añade una barra de colores como referencia. La tabla suele proceder de pivot_table: visits.pivot_table(index="day", columns="slot", values="visitors", aggfunc="mean").

Un museo cuenta los visitantes por cada medio día. Sábado por la mañana 120 y 140, sábado por la tarde 200; domingo por la mañana 90, domingo por la tarde 160; lunes por la mañana 40, lunes por la tarde 70 y 90. La tabla dinámica de medias contiene Mon 40 y 80, Sat 130 y 200, Sun 90 y 160 (mañana y tarde). sns.heatmap(pt, annot=True, fmt=".0f", cmap="Blues") muestra la celda con más visitantes, el sábado por la tarde, como la más oscura. La conversión a formato ancho ordena los días alfabéticamente (Mon, Sat, Sun); pt.reindex(["Sat", "Sun", "Mon"]) restablecería el orden elegido.

annot=True escribe cada valor en su celda y fmt establece el formato numérico. El valor predeterminado ".2g" conserva dos cifras significativas, por lo que 43,25 se muestra como «43» y 1234 como «1.2e+03». Utiliza fmt=".0f" para números enteros o fmt=".2f" para dos decimales; fmt="d" solo funciona con datos enteros y produce un ValueError con números de coma flotante.

Un mapa de calor de correlaciones parte de corr = df.corr(numeric_only=True), una tabla cuadrada y simétrica cuyos coeficientes definidos van de −1 a 1. Las columnas numéricas no constantes tienen 1 en la diagonal; las columnas constantes tienen correlaciones no definidas. En pandas 2 y versiones posteriores, el valor predeterminado de numeric_only es False, por lo que df.corr() produce un error cuando la tabla tiene una columna de texto. Dibújalo con sns.heatmap(corr, annot=True, fmt=".2f", cmap="vlag", vmin=-1, vmax=1, center=0).

Ocho días con temperatura (°C), alquileres de bicicletas, precipitación (mm) y viento (km/h). La matriz de correlaciones da temperatura y alquileres 0,92, alquileres y precipitación −0,82, precipitación y viento 0,75, y temperatura y viento −0,38. Con el mapa de colores «vlag», el par con una correlación positiva fuerte aparece en rojo intenso, el par con una correlación negativa fuerte en azul intenso y el par débil de temperatura y viento en un tono pálido cercano al centro blanco.

Sin vmin y vmax, los colores se extienden desde el valor mínimo hasta el máximo de esa tabla, por lo que el mismo color puede representar valores distintos en dos mapas de calor. Fija los límites para comparar mapas de calor y utiliza vmin=-1, vmax=1 para correlaciones. Un mapa de colores secuencial como «rocket» (el predeterminado de seaborn), «viridis» o «Blues» es adecuado para valores que van de bajos a altos; uno divergente como «vlag», «coolwarm» o «RdBu_r», con center en el punto medio significativo, es adecuado para valores por encima y por debajo de una referencia como 0. Si se establece center y no se indica cmap, seaborn utiliza el mapa divergente «icefire».

Opciones útiles: linewidths=0.5 dibuja líneas finas entre las celdas, square=True hace que las celdas sean cuadradas, cbar_kws={"label": "Visitors"} etiqueta la barra de colores y los valores faltantes (NaN) se dejan en blanco. mask=np.triu(np.ones_like(corr, dtype=bool)) oculta el triángulo superior y la diagonal de una matriz de correlaciones, que repiten el triángulo inferior.

En Matplotlib, im = ax.imshow(values, cmap="viridis"); fig.colorbar(im, ax=ax) dibuja un mapa de calor de un arreglo de 2 dimensiones, con la fila 0 arriba; «viridis» es el mapa de colores predeterminado de Matplotlib. imshow etiqueta los ejes con números de fila y columna, así que establece tú los nombres: ax.set_xticks(range(len(cols)), labels=cols). ax.pcolormesh es una alternativa cuando las celdas tienen tamaños distintos.

Un coeficiente de correlación mide únicamente la intensidad de una asociación lineal. Una correlación cercana a 0 no descarta una relación curva fuerte, y un solo valor atípico puede aumentar o disminuir mucho un coeficiente. Comprueba los diagramas de dispersión correspondientes, por ejemplo con una matriz de gráficos por pares, antes de interpretar un mapa de calor de correlaciones.

Los gráficos múltiples en pequeños paneles son un conjunto de gráficos del mismo tipo, uno por cada subconjunto de datos, dibujados con las mismas escalas y colocados uno junto a otro para poder comparar los subconjuntos. En Matplotlib se construyen como una cuadrícula de áreas de trazado en una figura.

fig, axes = plt.subplots(2, 3, figsize=(12, 6)) devuelve una figura y un arreglo de NumPy de 2 × 3 áreas de trazado. axes[0, 0] es el panel superior izquierdo y axes[1, 2] el inferior derecho. Con una fila o una columna, el arreglo es unidimensional, por lo que plt.subplots(1, 3) da axes[0], axes[1] y axes[2]. axes.flat recorre todos los paneles fila por fila.

El propio arreglo no puede dibujar: axes.plot(...) produce AttributeError: 'numpy.ndarray' object has no attribute 'plot'. Selecciona primero un panel mediante su índice, como en axes[0, 1].plot(...).

sharex=True y sharey=True dan a todos los paneles los mismos límites de x o de y, de modo que alturas iguales representan valores iguales en todos los paneles y solo los paneles exteriores muestran etiquetas de graduación. Sin ejes compartidos, cada panel ajusta su escala a sus propios datos y un rango pequeño puede parecer tan grande como uno amplio.

fig, axes = plt.subplots(2, 2, sharey=True, layout="constrained"), seguido de for ax, (name, grp) in zip(axes.flat, rain.groupby("station")): ax.plot(grp["month_num"], grp["rain_mm"], marker="o"); ax.set_title(name). Las tres estaciones ocupan tres de los cuatro paneles; axes[1, 1].axis("off") oculta el cuarto, que está vacío.

Las etiquetas de paneles vecinos pueden superponerse. layout="constrained" en plt.subplots o plt.figure ajusta el espaciado automáticamente; fig.tight_layout(), llamado después de dibujar, es la alternativa más antigua. fig.suptitle("Monthly rainfall by station") añade un título para toda la figura, y fig.supxlabel(...) y fig.supylabel(...) añaden etiquetas de ejes compartidas.

Paneles de distintos tamaños: plt.subplots(1, 2, gridspec_kw={"width_ratios": [2, 1]}) hace que el panel izquierdo tenga el doble de ancho que el derecho. fig, axd = plt.subplot_mosaic([["top", "top"], ["left", "right"]]) devuelve un diccionario de áreas de trazado, en este caso un panel ancho axd["top"] sobre dos más pequeños.

Los gráficos de pandas y las funciones de seaborn a nivel de área de trazado pueden rellenar paneles elegidos con ax=: wide["North"].plot(ax=axes[0, 0]) o sns.histplot(data=commutes, x="minutes", ax=axes[0, 1]). Así se combinan gráficos de las tres bibliotecas en una figura.

La representación por facetas dibuja el mismo gráfico una vez por cada nivel de una variable categórica, cada uno en su propio panel, con ejes compartidos. Las funciones de seaborn a nivel de figura lo hacen con col= (paneles uno junto a otro), row= (paneles apilados) y col_wrap= (iniciar una nueva fila después de ese número de columnas).

sns.relplot(data=rain, x="month_num", y="rain_mm", col="station", col_wrap=2, kind="line", height=3, aspect=1.5) dibuja tres paneles, dos en la primera fila y uno en la segunda. Cada panel tiene 3 pulgadas de alto y 3 × 1,5 = 4,5 pulgadas de ancho, por lo que la figura mide aproximadamente 9 × 6 pulgadas.

row y col juntos crean una cuadrícula con un panel por cada combinación de niveles: dos estaciones del año como filas y tres estaciones de medición como columnas dan 2 × 3 = 6 paneles. col_wrap no se puede combinar con row.

Los mismos argumentos funcionan para todo tipo de gráficos: sns.displot(data=commutes, x="minutes", col="mode") produce un histograma por medio de transporte, y sns.catplot(data=rain, x="station", y="rain_mm", col="season", kind="box") produce diagramas de caja y bigotes por estación del año.

Los paneles comparten sus ejes x e y de forma predeterminada, por lo que se pueden comparar las alturas entre paneles. Permitir que cada panel ajuste su escala a sus propios datos muestra detalles dentro de grupos pequeños, pero hace que las comparaciones entre paneles resulten engañosas a primera vista. Con relplot y displot, pasa facet_kws={"sharey": False}; catplot acepta sharey=False directamente, y pasarlo también en facet_kws produce un TypeError.

sns.FacetGrid crea la cuadrícula directamente y luego dibuja en cada panel: g = sns.FacetGrid(commutes, col="mode", height=3); g.map_dataframe(sns.histplot, x="minutes"); g.add_legend(). g.map(plt.scatter, "temp_c", "rentals") pasa las columnas indicadas como argumentos posicionales a una función de representación.

Personaliza la cuadrícula con sus métodos: g.set_titles("{col_name}") establece los títulos de los paneles a partir de los nombres de los niveles, g.set_axis_labels("Month", "Rainfall (mm)") etiqueta todos los ejes y g.set(ylim=(0, 120)) aplica un ajuste del área de trazado a cada panel. g.axes_dict["Coast"] o g.axes.flat permite acceder a áreas de trazado individuales, y g.figure.suptitle("Rainfall by station", y=1.02) añade un título general encima de los paneles.

hue y col dividen los datos según una variable. hue superpone los grupos en una sola área de trazado, lo que facilita la comparación directa de unos pocos grupos; col los separa, lo que mantiene la legibilidad cuando las líneas o los puntos se superpondrían o cuando hay muchos grupos. Ambos pueden utilizarse a la vez, por ejemplo col="station", hue="season".

Las funciones a nivel de figura no dibujan en un área de trazado existente (relplot, displot y catplot ignoran ax= con una advertencia, y lmplot lo rechaza) y no aceptan figsize de Matplotlib (pasarlo produce un error): establece el tamaño de la cuadrícula con height y aspect. Para colocar un gráfico por facetas junto a otros gráficos en una figura de Matplotlib, crea los paneles con plt.subplots y funciones a nivel de área de trazado.

ax.text(x, y, "text") escribe texto en un punto indicado en coordenadas de los datos, las mismas unidades que los valores representados. ha («left», «center», «right») y va («top», «center», «bottom») alinean el texto con ese punto; fontsize y color establecen su estilo.

Con transform=ax.transAxes, las posiciones son fracciones del área de trazado: (0, 0) es la esquina inferior izquierda y (1, 1) la superior derecha. ax.text(0.02, 0.95, "n = 20", transform=ax.transAxes, va="top") mantiene una nota en la esquina superior izquierda independientemente de los datos y los límites. El texto en coordenadas de los datos se mueve cuando cambian los límites y puede terminar fuera del área de trazado.

ax.annotate("Wettest month", xy=(1, 110), xytext=(2, 115), arrowprops=dict(arrowstyle="->")) escribe el texto en xytext y dibuja una flecha hacia el punto xy; ambos están en coordenadas de los datos de forma predeterminada. textcoords="offset points" convierte xytext en un desplazamiento desde xy en puntos, por ejemplo xytext=(10, 10) para 10 puntos a la derecha y hacia arriba.

Las líneas de referencia atraviesan toda el área de trazado: ax.axhline(50, color="gray", linestyle="--", label="Target") dibuja una línea horizontal en y = 50, y ax.axvline(...) una vertical. ax.axvspan(6, 8, alpha=0.2) sombrea el intervalo de x = 6 a x = 8, por ejemplo un período de vacaciones. ax.hlines(y, xmin, xmax) dibuja líneas horizontales en un intervalo limitado.

En el histograma de los 20 tiempos de desplazamiento, la media es 650 ÷ 20 = 32,5 minutos y la mediana 30,5 minutos. ax.axvline(32.5, color="black", linestyle="--"); ax.text(33.5, 6.5, "mean 32.5 min") marca la media, que está a la derecha de la mediana porque unos pocos desplazamientos largos la elevan.

Valores de las barras: ax.bar_label(bars, fmt="%.0f") etiqueta las barras devueltas por ax.bar. Para las barras dibujadas por pandas o seaborn, las barras se almacenan en ax.containers, por lo que ax.bar_label(ax.containers[0]) etiqueta la primera serie. padding=3 aleja las etiquetas 3 puntos de los extremos de las barras.

Las formas proceden de matplotlib.patches: ax.add_patch(Rectangle((x, y), width, height, fill=False, edgecolor="red")) dibuja el contorno de una región en coordenadas de los datos, y Circle y Polygon funcionan del mismo modo.

El texto se puede calcular a partir de los datos con cadenas f, de modo que las etiquetas sigan siendo correctas cuando cambien los datos: ax.text(..., f"mean {commutes['minutes'].mean():.1f} min"). Las anotaciones se dibujan encima de los datos; colócalas en zonas vacías y utiliza pocas para que destaquen lo importante.

fig.savefig("rainfall.png") guarda la figura; la extensión del archivo determina el formato: PNG y JPEG son imágenes de mapa de bits compuestas por píxeles, mientras que SVG y PDF son gráficos vectoriales compuestos por formas. format="pdf" establece el formato de manera explícita.

Las imágenes de mapa de bits tienen un número fijo de píxeles y se desenfocan al ampliarlas; los archivos vectoriales se mantienen nítidos a cualquier tamaño y son adecuados para informes, impresión y documentos. PNG es un buen formato de mapa de bits para gráficos en la web y en presentaciones. La compresión JPEG tiene pérdida y desenfoca las líneas finas y el texto, por lo que es una mala opción para gráficos.

Tamaño en píxeles = tamaño de la figura en pulgadas × dpi (puntos por pulgada). fig, ax = plt.subplots(figsize=(8, 5)) guardado con dpi=150 da 8 × 150 por 5 × 150 = 1200 × 750 píxeles. Sin dpi, savefig utiliza los dpi propios de la figura, 100 de forma predeterminada, por lo que la misma figura pasa a tener 800 × 500 píxeles. En los formatos vectoriales, los dpi solo afectan a las partes de mapa de bits incrustadas.

El tamaño del texto y el ancho de las líneas se establecen en puntos (1 punto = 1/72 de pulgada), en relación con las pulgadas de la figura. Aumentar los dpi añade píxeles sin cambiar el tamaño aparente del texto respecto al gráfico; en cambio, aumentar figsize hace que el texto sea relativamente más pequeño. Elige figsize según el tamaño final de visualización y dpi según la nitidez.

bbox_inches="tight" recorta los márgenes vacíos e incluye los elementos que sobresalen de la figura, como una leyenda situada fuera del área de trazado; la imagen guardada resulta entonces un poco más pequeña o más grande que el tamaño de la figura × dpi. pad_inches=0.1 establece el margen que se conserva alrededor.

transparent=True guarda sin fondo, lo que resulta adecuado para diapositivas con un fondo de color; facecolor="white" fuerza un fondo blanco, lo que importa cuando un tema oscuro del cuaderno se trasladaría de otro modo al archivo.

plt.savefig guarda la figura actual, así que llámalo antes de una llamada bloqueante a plt.show(): una vez cerrada la ventana, pyplot deja de mantener la referencia a esa figura y una llamada posterior a plt.savefig(...) guarda una figura nueva y vacía. En un cuaderno de Jupyter, pyplot también deja de mantener la figura al final de la celda, por lo que plt.savefig en una celda posterior guarda una imagen vacía. Conservar la figura en una variable evita ambos problemas: fig.savefig(...) sigue funcionando después de plt.show() o en una celda posterior del cuaderno.

Los resultados de seaborn se guardan del mismo modo: un gráfico a nivel de área de trazado mediante su figura, ax.figure.savefig("box.png", dpi=200), y una cuadrícula a nivel de figura con g.savefig("facets.png", dpi=200), que utiliza cajas delimitadoras ajustadas de forma predeterminada.

for name, grp in rain.groupby("station"):
    grp = grp.sort_values("month_num")
    fig, ax = plt.subplots(figsize=(6, 4))
    ax.plot(grp["month_num"], grp["rain_mm"], marker="o")
    ax.set(title=name, xlabel="Month", ylabel="Rainfall (mm)")
    fig.savefig(f"rain_{name}.png", dpi=150, bbox_inches="tight")
    plt.close(fig)

. Cerrar cada figura mantiene bajo el uso de memoria y evita la advertencia sobre más de 20 figuras abiertas.