Création de plusieurs sous-parcelles à l'aide de plt.subplots

pyplot.subplotscrée une figure et une grille de sous-parcelles avec un seul appel, tout en offrant un contrôle raisonnable sur la façon dont les parcelles individuelles sont créées. Pour des cas d'utilisation plus avancés, vous pouvez utiliser GridSpecpour une disposition de sous-parcelles plus générale ou Figure.add_subplotpour ajouter des sous-parcelles à des emplacements arbitraires dans la figure.

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)

Une figure avec une seule sous-parcelle

subplots()sans arguments renvoie un Figureet un seul Axes.

C'est en fait la manière la plus simple et la plus recommandée de créer une seule figure et des axes.

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

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

Empiler les sous-parcelles dans une direction

Les deux premiers arguments facultatifs de pyplot.subplotsdéfinissent le nombre de lignes et de colonnes de la grille de sous-parcelles.

Lors de l'empilement dans une seule direction, le retour axsest un tableau numpy 1D contenant la liste des axes créés.

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 vous ne créez que quelques Axes, il est pratique de les décompresser immédiatement dans des variables dédiées à chaque Axe. De cette façon, nous pouvons utiliser ax1à la place du plus verbeux 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>]

Pour obtenir des sous-parcelles côte à côte, transmettez des paramètres pour une ligne et deux colonnes.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>]

Empiler des sous-parcelles dans deux directions

Lors de l'empilement dans deux directions, le résultat axsest un tableau NumPy 2D.

Si vous devez définir des paramètres pour chaque sous-parcelle, il est pratique de parcourir toutes les sous-parcelles d'une grille 2D à l'aide de .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()

Vous pouvez également utiliser le tuple-unpacking en 2D pour affecter toutes les sous-parcelles à des variables dédiées :

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()

Partage d'axes

Par défaut, chaque Axe est mis à l'échelle individuellement. Ainsi, si les plages sont différentes, les valeurs des graduations des sous-parcelles ne s'alignent pas.

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>]

Vous pouvez utiliser sharex ou sharey pour aligner l'axe horizontal ou 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>]

La définition de sharex ou sharey pour Trueactiver le partage global sur l'ensemble de la grille, c'est-à-dire que les axes y des sous-parcelles empilées verticalement ont la même échelle lors de l'utilisation de 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>]

Pour les sous-parcelles qui partagent des axes, un ensemble d'étiquettes de graduation suffit. Les étiquettes de coche des axes internes sont automatiquement supprimées par sharex et sharey . Il reste encore un espace vide inutilisé entre les sous-parcelles.

Pour contrôler précisément le positionnement des sous-parcelles, on peut explicitement créer un GridSpecwith Figure.add_gridspec, puis appeler sa subplotsméthode. Par exemple, nous pouvons réduire la hauteur entre les sous-parcelles verticales en utilisant add_gridspec(hspace=0).

label_outerest une méthode pratique pour supprimer les étiquettes et les graduations des sous-parcelles qui ne sont pas au bord de la grille.

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()

En dehors de Trueet False, sharex et sharey acceptent les valeurs 'row' et 'col' pour partager les valeurs uniquement par ligne ou colonne.

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 vous souhaitez une structure de partage plus complexe, vous pouvez d'abord créer la grille d'axes sans partage, puis appeler axes.Axes.sharexou axes.Axes.shareypour ajouter des informations de partage 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()

Axes polaires

Le paramètre subplot_kw de pyplot.subplotscontrôle les propriétés de la sous-parcelle (voir aussi Figure.add_subplot). En particulier, cela peut être utilisé pour créer une grille d'axes polaires.

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

plt.show()