Creando múltiples subparcelas usando plt.subplots

pyplot.subplotscrea una figura y una cuadrícula de subparcelas con una sola llamada, al tiempo que proporciona un control razonable sobre cómo se crean las parcelas individuales. Para casos de uso más avanzados, puede usar GridSpecpara un diseño de subgráfico más general o Figure.add_subplotpara agregar subgráficos en ubicaciones arbitrarias dentro de la figura.

import matplotlib.pyplot as plt
import numpy as np

# Some example data to display
x = np.linspace(0, 2 * np.pi, 400)
y = np.sin(x ** 2)

Una figura con una sola subtrama

subplots()sin argumentos devuelve a Figurey a single Axes.

Esta es en realidad la forma más sencilla y recomendada de crear una única figura y ejes.

fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title('A single plot')

Text(0.5, 1.0, 'A single plot')

Apilando subparcelas en una dirección

Los dos primeros argumentos opcionales de pyplot.subplotsdefinen el número de filas y columnas de la cuadrícula de la subparcela.

Cuando se apila en una sola dirección, el axsresultado es una matriz numérica 1D que contiene la lista de ejes creados.

fig, axs = plt.subplots(2)
fig.suptitle('Vertically stacked subplots')
axs[0].plot(x, y)
axs[1].plot(x, -y)

[<matplotlib.lines.Line2D object at 0x7f2d00efd510>]

Si está creando solo unos pocos ejes, es útil descomprimirlos inmediatamente en variables dedicadas para cada eje. De esa manera, podemos usar ax1en lugar del más detallado axs[0].

fig, (ax1, ax2) = plt.subplots(2)
fig.suptitle('Vertically stacked subplots')
ax1.plot(x, y)
ax2.plot(x, -y)

[<matplotlib.lines.Line2D object at 0x7f2d00a95b70>]

Para obtener subparcelas una al lado de la otra, pase parámetros para una fila y dos columnas.1, 2

fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle('Horizontally stacked subplots')
ax1.plot(x, y)
ax2.plot(x, -y)

[<matplotlib.lines.Line2D object at 0x7f2cfb43d330>]

Apilando subtramas en dos direcciones

Cuando se apila en dos direcciones, el resultado axses una matriz 2D NumPy.

Si tiene que establecer parámetros para cada subparcela, es útil iterar sobre todas las subparcelas en una cuadrícula 2D usando .for ax in axs.flat:

fig, axs = plt.subplots(2, 2)
axs[0, 0].plot(x, y)
axs[0, 0].set_title('Axis [0, 0]')
axs[0, 1].plot(x, y, 'tab:orange')
axs[0, 1].set_title('Axis [0, 1]')
axs[1, 0].plot(x, -y, 'tab:green')
axs[1, 0].set_title('Axis [1, 0]')
axs[1, 1].plot(x, -y, 'tab:red')
axs[1, 1].set_title('Axis [1, 1]')

for ax in axs.flat:
    ax.set(xlabel='x-label', ylabel='y-label')

# Hide x labels and tick labels for top plots and y ticks for right plots.
for ax in axs.flat:
    ax.label_outer()

Puede usar el desempaquetado de tuplas también en 2D para asignar todas las subparcelas a variables dedicadas:

fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)
fig.suptitle('Sharing x per column, y per row')
ax1.plot(x, y)
ax2.plot(x, y**2, 'tab:orange')
ax3.plot(x, -y, 'tab:green')
ax4.plot(x, -y**2, 'tab:red')

for ax in fig.get_axes():
    ax.label_outer()

Compartiendo ejes

De forma predeterminada, cada eje se escala individualmente. Por lo tanto, si los rangos son diferentes, los valores de marca de las subparcelas no se alinean.

fig, (ax1, ax2) = plt.subplots(2)
fig.suptitle('Axes values are scaled individually by default')
ax1.plot(x, y)
ax2.plot(x + 1, -y)

[<matplotlib.lines.Line2D object at 0x7f2cfb007250>]

Puede usar sharex o sharey para alinear el eje horizontal o vertical.

fig, (ax1, ax2) = plt.subplots(2, sharex=True)
fig.suptitle('Aligning x-axis using sharex')
ax1.plot(x, y)
ax2.plot(x + 1, -y)

[<matplotlib.lines.Line2D object at 0x7f2cfa993370>]

Configurar sharex o sharey para Truehabilitar el intercambio global en toda la cuadrícula, es decir, también los ejes y de las subparcelas apiladas verticalmente tienen la misma escala cuando se usa sharey=True.

fig, axs = plt.subplots(3, sharex=True, sharey=True)
fig.suptitle('Sharing both axes')
axs[0].plot(x, y ** 2)
axs[1].plot(x, 0.3 * y, 'o')
axs[2].plot(x, y, '+')

[<matplotlib.lines.Line2D object at 0x7f2cfab12980>]

Para las subparcelas que comparten ejes, un conjunto de etiquetas de marca es suficiente. Sharex y sharey eliminan automáticamente las etiquetas de marca de los ejes internos . Todavía queda un espacio vacío sin usar entre las subtramas.

Para controlar con precisión el posicionamiento de las subparcelas, se puede crear explícitamente un GridSpecwith Figure.add_gridspecy luego llamar a su subplotsmétodo. Por ejemplo, podemos reducir la altura entre subparcelas verticales usando add_gridspec(hspace=0).

label_outeres un método útil para eliminar etiquetas y marcas de subparcelas que no están en el borde de la cuadrícula.

fig = plt.figure()
gs = fig.add_gridspec(3, hspace=0)
axs = gs.subplots(sharex=True, sharey=True)
fig.suptitle('Sharing both axes')
axs[0].plot(x, y ** 2)
axs[1].plot(x, 0.3 * y, 'o')
axs[2].plot(x, y, '+')

# Hide x labels and tick labels for all but bottom plot.
for ax in axs:
    ax.label_outer()

Aparte de Truey False, tanto sharex como sharey aceptan los valores 'row' y 'col' para compartir los valores solo por fila o columna.

fig = plt.figure()
gs = fig.add_gridspec(2, 2, hspace=0, wspace=0)
(ax1, ax2), (ax3, ax4) = gs.subplots(sharex='col', sharey='row')
fig.suptitle('Sharing x per column, y per row')
ax1.plot(x, y)
ax2.plot(x, y**2, 'tab:orange')
ax3.plot(x + 1, -y, 'tab:green')
ax4.plot(x + 2, -y**2, 'tab:red')

for ax in axs.flat:
    ax.label_outer()

Si desea una estructura de uso compartido más compleja, primero puede crear la cuadrícula de ejes sin compartir y luego llamar axes.Axes.sharexo axes.Axes.shareypara agregar información de uso compartido a posteriori.

fig, axs = plt.subplots(2, 2)
axs[0, 0].plot(x, y)
axs[0, 0].set_title("main")
axs[1, 0].plot(x, y**2)
axs[1, 0].set_title("shares x with main")
axs[1, 0].sharex(axs[0, 0])
axs[0, 1].plot(x + 1, y + 1)
axs[0, 1].set_title("unrelated")
axs[1, 1].plot(x + 2, y + 2)
axs[1, 1].set_title("also unrelated")
fig.tight_layout()

Ejes polares

El parámetro subplot_kw de pyplot.subplotscontrola las propiedades de la subparcela (ver también Figure.add_subplot). En particular, esto se puede usar para crear una cuadrícula de ejes polares.

fig, (ax1, ax2) = plt.subplots(1, 2, subplot_kw=dict(projection='polar'))
ax1.plot(x, y)
ax2.plot(x, y ** 2)

plt.show()