Grille Matplotlib

Matplotlib utilise le mot « grille » dans deux sens distincts : les mises en page multi-graphiques (disposer plusieurs axes côte à côte dans une figure) et les quadrillages d'arrière-plan (les lignes de référence tracées derrière les données sur un axe unique). Ce chapitre couvre les deux aspects, en commençant par les grilles de mise en page et en terminant par le style des quadrillages.

Vous devez déjà être à l'aise avec le tracé de base — si ce n'est pas le cas, consultez d'abord les chapitres Matplotlib Plotting et Matplotlib Subplot.

Mises en page multi-graphiques

Lorsque vous devez afficher plusieurs graphiques liés dans une même figure, vous les disposez dans une grille de lignes et de colonnes. Matplotlib propose trois approches, chacune adaptée à différents niveaux de complexité.

plt.subplots() — la méthode rapide

plt.subplots(nrows, ncols) est la voie la plus rapide pour des grilles uniformes où chaque sous-graphique a la même taille. Elle retourne une Figure et un array NumPy d'objets Axes.

import matplotlib.pyplot as plt

# 2-row, 2-column grid — four equal subplots
fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(8, 6))

axs[0, 0].plot([1, 2, 3], [4, 5, 6])
axs[0, 0].set_title("Line plot")

axs[0, 1].scatter([1, 2, 3], [4, 5, 6])
axs[0, 1].set_title("Scatter plot")

axs[1, 0].bar([1, 2, 3], [4, 5, 6])
axs[1, 0].set_title("Bar chart")

axs[1, 1].hist([1, 2, 3, 4, 5, 6], bins=3)
axs[1, 1].set_title("Histogram")

plt.tight_layout()
plt.show()

tight_layout() ajuste automatiquement l'espacement pour que les titres et les étiquettes de graduation ne se chevauchent pas. Passez figsize=(width, height) en pouces pour contrôler la taille globale de la figure.

Partage des axes

Quand des graphiques partagent la même échelle, vous pouvez lier leurs axes de sorte que le zoom sur l'un s'applique à tous :

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 100)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9, 3), sharey=True)

ax1.plot(x, np.sin(x))
ax1.set_title("sin(x)")

ax2.plot(x, np.cos(x))
ax2.set_title("cos(x)")

plt.tight_layout()
plt.show()

sharey=True lie la plage de l'axe des y entre les deux sous-graphiques ; sharex=True fait de même pour l'axe des x.

GridSpec — cellules de taille variable

GridSpec vous permet d'attribuer des pondérations différentes aux lignes et aux colonnes, afin que certains sous-graphiques puissent être plus hauts ou plus larges que d'autres. Il permet également à un seul sous-graphique de s'étendre sur plusieurs cellules.

import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

fig = plt.figure(figsize=(9, 6))

# 2 rows, 3 columns; bottom row is twice as tall
gs = GridSpec(nrows=2, ncols=3, height_ratios=[1, 2], hspace=0.4, wspace=0.3)

ax_top_left   = fig.add_subplot(gs[0, 0])
ax_top_mid    = fig.add_subplot(gs[0, 1])
ax_top_right  = fig.add_subplot(gs[0, 2])
ax_bottom     = fig.add_subplot(gs[1, :])   # spans all three columns

ax_top_left.plot([0, 1, 2], [0, 1, 0])
ax_top_left.set_title("Top left")

ax_top_mid.bar([0, 1, 2], [3, 1, 4])
ax_top_mid.set_title("Top centre")

ax_top_right.scatter([0, 1, 2], [2, 7, 1])
ax_top_right.set_title("Top right")

ax_bottom.plot([0, 1, 2, 3, 4], [0, 1, 4, 9, 16], color="steelblue", linewidth=2)
ax_bottom.set_title("Bottom — full width")

plt.show()

Arguments clés de GridSpec :

Le découpage avec gs[row, col] fonctionne comme avec NumPy : gs[1, :] s'étend sur toutes les colonnes ; gs[:, 0] s'étend sur toutes les lignes de la première colonne.

subplot_mosaic() — mise en page depuis une chaîne de caractères

Introduite dans Matplotlib 3.3, subplot_mosaic() vous permet de décrire la mise en page à l'aide d'une chaîne de caractères ou d'une liste imbriquée qui ressemble à une carte ASCII de la figure. C'est souvent l'approche la plus lisible pour les mises en page asymétriques.

import matplotlib.pyplot as plt

layout = """
AB
CC
"""

fig, axes = plt.subplot_mosaic(layout, figsize=(8, 5))

axes["A"].set_title("Panel A")
axes["A"].plot([1, 2, 3], [3, 1, 2])

axes["B"].set_title("Panel B")
axes["B"].scatter([1, 2, 3], [2, 3, 1])

axes["C"].set_title("Panel C — full width")
axes["C"].bar(["x", "y", "z"], [5, 3, 7])

plt.tight_layout()
plt.show()

Chaque lettre unique dans la chaîne devient un objet Axes. Des lettres répétées dans la même ligne/colonne font que ce sous-graphique s'étend sur ces cellules. Le dictionnaire axes retourné est indexé par étiquette, ce qui rend l'accès aux panneaux par nom plus clair que l'indexation numérique.

Contrôle de l'espacement : tight_layout vs constrained_layout

Deux systèmes intégrés gèrent l'espacement automatique :

• plt.tight_layout() — à appeler avant plt.show(). Ajuste les paramètres des sous-graphiques pour que les étiquettes et les titres tiennent. Simple et fiable pour la plupart des mises en page.
• constrained_layout=True — à passer à plt.subplots() ou plt.figure(). Résout un système de contraintes au moment du rendu ; gère mieux les barres de couleur et les titres généraux que tight_layout.

import matplotlib.pyplot as plt

# constrained_layout keeps the super-title from overlapping the subplots
fig, axs = plt.subplots(1, 2, figsize=(8, 3), constrained_layout=True)

fig.suptitle("Two plots with constrained_layout", fontsize=13)

axs[0].plot([1, 2, 3], [1, 4, 9])
axs[0].set_title("Subplot 1")

axs[1].plot([1, 2, 3], [9, 4, 1])
axs[1].set_title("Subplot 2")

plt.show()

N'utilisez pas les deux en même temps — ils entrent en conflit. constrained_layout est le choix le plus moderne.

Pour un contrôle manuel, fig.subplots_adjust(left, right, top, bottom, hspace, wspace) remplace entièrement l'espacement automatique.

Quadrillages d'arrière-plan

Sur un axe unique, ax.grid() trace des lignes de référence aux positions des graduations. Celles-ci sont différentes de la grille de mise en page décrite précédemment — ce sont des guides visuels tracés derrière les données représentées.

Activation du quadrillage

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(6, 4))

ax.plot([1, 2, 3, 4, 5], [2, 5, 3, 8, 6], marker="o")

# Enable gridlines on both axes
ax.grid(True)

ax.set_title("Plot with gridlines")
plt.tight_layout()
plt.show()

Style du quadrillage

Passez des arguments nommés à ax.grid() pour modifier l'apparence :

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(6, 4))

ax.plot([1, 2, 3, 4, 5], [2, 5, 3, 8, 6], marker="o", color="steelblue")

ax.grid(
    True,
    which="major",      # "major", "minor", or "both"
    axis="both",        # "x", "y", or "both"
    color="gray",
    linestyle="--",
    linewidth=0.7,
    alpha=0.7,
)

ax.set_title("Styled gridlines")
plt.tight_layout()
plt.show()

Quadrillage principal et secondaire

Matplotlib distingue les graduations principales (celles avec étiquettes) des graduations secondaires (subdivisions sans étiquettes). Vous pouvez afficher des quadrillages aux deux niveaux :

import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator

fig, ax = plt.subplots(figsize=(7, 4))

ax.plot([0, 1, 2, 3, 4, 5, 6], [0, 1, 4, 9, 16, 25, 36])

# Major gridlines every 1 unit, minor every 0.5
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.xaxis.set_minor_locator(MultipleLocator(0.5))
ax.yaxis.set_major_locator(MultipleLocator(10))
ax.yaxis.set_minor_locator(MultipleLocator(5))

ax.grid(True, which="major", linestyle="-",  linewidth=0.8, color="gray",  alpha=0.6)
ax.grid(True, which="minor", linestyle=":",  linewidth=0.5, color="silver", alpha=0.5)

ax.set_title("Major and minor gridlines")
plt.tight_layout()
plt.show()

Activation des graduations secondaires sans localisateur

Si vous souhaitez simplement afficher des graduations secondaires sans les placer manuellement :

ax.minorticks_on()
ax.grid(True, which="both")

Style avec les feuilles de style Matplotlib

Les quadrillages sont également contrôlés par les feuilles de style. Le style seaborn-v0_8-whitegrid, par exemple, active automatiquement les quadrillages horizontaux :

import matplotlib.pyplot as plt

plt.style.use("seaborn-v0_8-whitegrid")

fig, ax = plt.subplots(figsize=(6, 4))
ax.plot([1, 2, 3, 4], [3, 7, 2, 9], marker="s")
ax.set_title("seaborn-v0_8-whitegrid style")
plt.tight_layout()
plt.show()

Exécutez plt.style.available pour lister tous les styles intégrés.

Choisir la bonne approche

Chapitres associés

• Matplotlib Subplot — exploration approfondie de plt.subplots() et des objets axes
• Matplotlib Labels — ajout de titres, d'étiquettes d'axes et d'annotations
• Matplotlib Plotting — graphiques linéaires, diagrammes en barres et camemberts
• Matplotlib Scatter — nuages de points et personnalisation des marqueurs