Architecture des figures et des axes
Comprenez la hiérarchie Figure-Axes-Artist, créez des graphiques avec plt.subplots() et distinguez les API sans état des API orientées objet.
Architecture des figures et des axes est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Pourquoi apprendre l’architecture de Matplotlib ?
Pandas et Seaborn utilisent tous deux Matplotlib en interne. Comprendre la hiérarchie des objets de Matplotlib vous permet de contrôler chaque aspect d’un graphique — de la zone de dessin globale aux graduations individuelles — et de combiner plusieurs graphiques dans une même figure. Sans comprendre le modèle Figure-Axes, personnaliser des graphiques devient rapidement un exercice frustrant consistant à deviner quelle fonction appeler.
La Figure : la zone de dessin
Une Figure est le conteneur extérieur, c’est-à-dire la fenêtre ou le fichier image entier. Elle contient un ou plusieurs objets Axes (les zones de graphique proprement dites), ainsi qu’un titre, des légendes communes et des espaces vides. Vous créez une Figure avec plt.figure() ou implicitement avec plt.subplots(). La plupart des propriétés définies sur la Figure s’appliquent à l’ensemble de la zone de dessin : taille, couleur d’arrière-plan et titre général.
import matplotlib.pyplot as plt
import numpy as np
# Create a Figure with a specific size
fig = plt.figure(figsize=(8, 4)) # width=8 inches, height=4 inches
print(type(fig)) # matplotlib.figure.Figure
print('Figure size:', fig.get_size_inches())
plt.close() # close to avoid display in scriptsLes Axes : là où les graphiques sont tracés
Un objet Axes est une zone de graphique unique au sein d’une Figure. Il contient l’axe des abscisses, l’axe des ordonnées, les graduations, les lignes de grille et tous les éléments visuels (lignes, barres, points de dispersion). La plupart des appels de traçage sont des méthodes d’un objet Axes : ax.plot(), ax.bar(), ax.scatter(). Une Figure peut contenir plusieurs Axes, organisés sous forme de grille de sous-graphiques.
fig, ax = plt.subplots() # Creates Figure + one Axes
print(type(ax)) # matplotlib.axes.Axes
x = np.linspace(0, 10, 100)
ax.plot(x, np.sin(x)) # plot on the Axes
plt.tight_layout()
# plt.show()
plt.close()plt.subplots() : créer une Figure et des Axes ensemble
plt.subplots(nrows, ncols) est la méthode recommandée pour créer une Figure avec un ou plusieurs Axes disposés selon une grille. Elle renvoie un tuple (fig, ax) (ou (fig, axes_array) pour plusieurs sous-graphiques). Le paramètre figsize définit la taille totale de la zone de dessin en pouces. Décomposez toujours le résultat dans des variables nommées afin de conserver un code clair.
# Single plot
fig, ax = plt.subplots(figsize=(6, 4))
# 2 rows, 1 column
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(6, 8))
# 2 rows, 2 columns
fig, axes = plt.subplots(2, 2, figsize=(10, 8))
ax_top_left = axes[0, 0]
ax_top_right = axes[0, 1]
print('axes shape:', axes.shape) # (2, 2)
plt.close('all')API orientée objet ou à état
Matplotlib propose deux styles d’utilisation. L’API à état (pyplot) utilise plt.plot(), plt.xlabel(), etc., et agit sur les axes « actuels », ce qui est pratique pour une exploration interactive rapide. L’API orientée objet (OO) appelle explicitement des méthodes sur des objets ax : ax.plot(), ax.set_xlabel(). L’API OO est fortement recommandée pour le code destiné à la production et les figures à plusieurs panneaux, car elle indique sans ambiguïté quels axes sont modifiés.
x = [1, 2, 3, 4]
y = [1, 4, 9, 16]
# Stateful API (convenient but fragile)
# plt.plot(x, y)
# plt.xlabel('x')
# plt.title('Squares')
# Object-oriented API (preferred)
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_xlabel('x')
ax.set_title('Squares')
plt.close()Les artistes : les éléments constitutifs
Tout ce qui est visible dans un graphique Matplotlib est un artiste : la figure, les axes, les lignes, le texte, les éléments graphiques (des rectangles pour les barres) et les marqueurs. La hiérarchie Figure-Axes-Artiste va du conteneur le plus extérieur jusqu'au plus petit élément visuel. Comprendre cette hiérarchie vous aide à localiser et à modifier n'importe quel élément par programmation — par exemple, pour changer la couleur d'une barre précise une fois le graphique dessiné.
fig, ax = plt.subplots()
line, = ax.plot([1, 2, 3], [1, 4, 9], color='blue', linewidth=2)
# Introspect the hierarchy
print('Figure:', type(fig))
print('Axes:', type(ax))
print('Line Artist:', type(line))
print('Line color:', line.get_color())
plt.close()Objets Axis : XAxis et YAxis
Chaque objet Axes contient deux objets Axis (à ne pas confondre avec Axes) : ax.xaxis et ax.yaxis. Ils contrôlent les graduations, leurs étiquettes et la bordure (la ligne visible). Vous pouvez définir les limites des axes avec ax.set_xlim() et ax.set_ylim(), contrôler la fréquence des graduations avec ax.set_xticks() et formater les étiquettes avec ax.xaxis.set_major_formatter().
fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4], [10, 40, 30, 70])
ax.set_xlim(0, 5)
ax.set_ylim(0, 80)
ax.set_xticks([1, 2, 3, 4])
ax.set_xticklabels(['Q1', 'Q2', 'Q3', 'Q4'])
ax.set_xlabel('Quarter')
ax.set_ylabel('Revenue')
plt.close()Axes partagés pour les graphiques à plusieurs panneaux
Lors de la création d'une grille de sous-graphiques, transmettez sharex=True ou sharey=True à plt.subplots() pour relier les échelles des axes entre les panneaux. Ainsi, effectuer un zoom ou faire défiler un sous-graphique met automatiquement à jour tous les panneaux qui partagent cet axe — ce qui est essentiel pour comparer des séries temporelles entre plusieurs groupes lorsque la même plage sur l'axe des x doit être affichée dans chaque panneau.
import numpy as np
x = np.arange(10)
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(6, 5))
ax1.plot(x, x**2, color='blue')
ax1.set_title('Squares')
ax2.plot(x, x**3, color='red')
ax2.set_title('Cubes')
fig.suptitle('Powers of x') # shared figure title
plt.tight_layout()
plt.close()Espacement avec tight_layout()
plt.tight_layout() (ou fig.tight_layout()) ajuste automatiquement les paramètres des sous-graphiques afin de réduire au minimum le chevauchement entre les étiquettes, les titres et les graduations. Appelez-la juste avant plt.show() ou fig.savefig(). Pour un contrôle plus précis, utilisez plt.subplots_adjust(hspace=, wspace=) afin de définir manuellement l'espace vertical et horizontal entre les sous-graphiques.
fig, axes = plt.subplots(2, 2, figsize=(10, 8))
for i, ax in enumerate(axes.flat):
ax.plot([1, 2, 3], [i, i+1, i+2])
ax.set_title(f'Panel {i+1}')
ax.set_xlabel('x axis label')
ax.set_ylabel('y axis label')
fig.suptitle('Grid of Plots', y=1.02)
plt.tight_layout() # prevents overlapping labels
plt.close()Accéder aux Axes depuis subplots()
Lorsque plt.subplots(nrows, ncols) renvoie plusieurs axes, ceux-ci sont regroupés dans un tableau NumPy de forme (nrows, ncols). Accédez-y comme à n'importe quel tableau 2D : axes[0, 1] désigne la première ligne et la deuxième colonne. Utilisez axes.flat pour parcourir tous les axes dans l'ordre ligne par ligne, quelle que soit la forme de la grille — c'est très pratique pour appliquer la même mise en forme à chaque panneau.
fig, axes = plt.subplots(2, 3, figsize=(12, 6))
# Access by row, column
axes[0, 0].set_title('Top Left')
axes[1, 2].set_title('Bottom Right')
# Iterate over all axes
for ax in axes.flat:
ax.set_xlabel('Time')
ax.set_ylabel('Value')
plt.tight_layout()
plt.close()Supprimer les axes inutilisés
Lorsque vous créez une grille de sous-graphiques sans utiliser chaque panneau, les axes vides affichent toujours les bordures du cadre. Appelez ax.set_visible(False) ou fig.delaxes(ax) pour masquer ou supprimer les axes inutilisés. Une méthode courante consiste à parcourir axes.flat et à masquer tous les panneaux situés au-delà du nombre de séries de données que vous représentez, afin de conserver une figure claire.
fig, axes = plt.subplots(2, 3, figsize=(12, 6))
data_panels = 4 # only 4 plots needed in a 2x3 grid
for i, ax in enumerate(axes.flat):
if i < data_panels:
ax.plot([1, 2, 3], [i, i+1, i+2])
ax.set_title(f'Panel {i+1}')
else:
ax.set_visible(False) # hide extra panels
plt.tight_layout()
plt.close()Vérification rapide
Vérifiez votre compréhension de l'architecture Figure et Axes de Matplotlib présentée dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que la Figure est l'ensemble de la zone de dessin et que les Axes désignent une seule zone de graphique à l'intérieur de celle-ci ; plt.subplots() crée les deux à la fois et renvoie (fig, ax) ; l'API orientée objet (ax.plot(), ax.set_xlabel()) est préférable à l'API pyplot à état ; et tight_layout() empêche le chevauchement des étiquettes dans les figures à plusieurs panneaux. Ensuite, nous créerons des graphiques linéaires et des nuages de points en contrôlant entièrement leur style.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Architecture des figures et des axes » est-elle gratuite ?
Oui — le texte complet de « Architecture des figures et des axes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Architecture des figures et des axes » ?
Comprenez la hiérarchie Figure-Axes-Artist, créez des graphiques avec plt.subplots() et distinguez les API sans état des API orientées objet. Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?
Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Architecture des figures et des axes » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?
Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Architecture des figures et des axes
- Graphiques linéaires et nuages de points
- Graphiques en barres et histogrammes
- Libellés, titres et enregistrement des figures