Skip to content

Matplotlib Aide-mémoire

Bibliothèque Python complète de tracé pour la visualisation de données.

01

Premiers pas

Installation et premier graphique

Matplotlib est le socle du tracé en Python. pyplot est l'interface à état (comme MATLAB). Appelez toujours plt.show() pour afficher la figure dans un script ; dans un notebook Jupyter, la figure s'affiche automatiquement à la fin d'une cellule.

matplotlib
# install
pip install matplotlib

import matplotlib.pyplot as plt
import numpy as np

# a simple line plot
x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y)
plt.title("Sine Wave")
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.show()

Interface à état pyplot

L'interface pyplot imite MATLAB : chaque appel opère sur la figure/les axes « courants » suivis en interne. Elle est concise pour des tracés rapides mais devient confuse avec plusieurs subplots. Utilisez plt.gcf()/plt.gca() pour accéder aux objets figure/axes courants.

matplotlib
import matplotlib.pyplot as plt

# pyplot tracks the "current" figure and axes
plt.figure()             # create a new figure
plt.plot([1, 2, 3], [4, 5, 2])
plt.title("State-based")  # applies to the current axes
plt.xlim(0, 4)
plt.ylim(0, 6)
plt.show()

# plt.gcf() -> current figure, plt.gca() -> current axes
print(plt.gca())

Figure et Axes (interface OO)

L'interface orientée objet (OO) est l'approche recommandée dès qu'on dépasse un seul graphique. Vous créez une Figure (le canevas entier) et un ou plusieurs Axes (graphiques individuels) et appelez des méthodes dessus. Elle passe proprement aux subplots, axes jumeaux et mises en page complexes.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

# object-oriented interface: explicit Figure and Axes objects
fig, ax = plt.subplots()      # fig is the canvas, ax is a single Axes
x = np.linspace(0, 5, 50)
ax.plot(x, x**2, label="x^2")
ax.plot(x, x**3, label="x^3")
ax.set_title("OO Interface")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.legend()
plt.show()

Imports et conventions courantes

plt est l'alias quasi universel de pyplot et np celui de NumPy — presque tous les tutoriels et bibliothèques les attendent. rcParams est le dictionnaire de configuration global : réglez-le une fois en haut d'un script pour fixer DPI, taille de police, taille de figure et bien d'autres défauts.

matplotlib
# the universal alias
import matplotlib.pyplot as plt
import numpy as np

# for the OO interface you often see
from matplotlib.figure import Figure
from matplotlib.axes import Axes

# set a global style once
plt.rcParams["figure.dpi"] = 100
plt.rcParams["font.size"] = 11

# inline backend in Jupyter (not needed in scripts)
# %matplotlib inline

Backends et plt.show()

Un backend rend la figure : les backends interactifs (TkAgg, Qt5Agg) ouvrent une fenêtre, les non interactifs (Agg) écrivent seulement des fichiers. Appelez matplotlib.use() avant d'importer pyplot. plt.show() bloque dans les scripts jusqu'à la fermeture des fenêtres ; dans Jupyter, %matplotlib inline intègre les figures dans le notebook.

matplotlib
import matplotlib

# list available backends
print(matplotlib.rcsetup.all_backends)

# force a backend (do this BEFORE importing pyplot)
# matplotlib.use("Agg")        # non-interactive, for saving files
# matplotlib.use("TkAgg")      # interactive Tk window

import matplotlib.pyplot as plt
plt.plot([1, 2, 3])
# plt.show() blocks until the window is closed
plt.savefig("out.png")  # saving works without any GUI backend
02

Courbes (plot)

Courbe simple

plt.plot(x, y) trace une ligne reliant les points (x, y) dans l'ordre. Si vous passez un seul tableau, il sert de y et x vaut par défaut 0..N-1. plt.grid(True) active/désactive les lignes de grille. Les points sont reliés dans l'ordre du tableau : pour une courbe lisse, triez d'abord x.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.5)
y = x * 2

plt.plot(x, y)
plt.title("y = 2x")
plt.xlabel("x")
plt.ylabel("y")
plt.grid(True)
plt.show()

Plusieurs courbes

Chaque appel plt.plot() ajoute une nouvelle courbe aux axes courants et avance automatiquement le cycle de couleurs. Passez un label= à chacune pour que plt.legend() puisse les identifier. Matplotlib gère les limites d'axes automatiquement, en s'adaptant à la plus grande plage.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 100)
plt.plot(x, np.sin(x), label="sin")
plt.plot(x, np.cos(x), label="cos")
plt.plot(x, np.sin(x) + np.cos(x), label="sin+cos")
plt.legend()
plt.title("Trig Functions")
plt.show()

Styles de ligne et marqueurs

La chaîne de format 'couleur+marqueur+style de ligne' (ex. 'ro--') est compacte mais hermétique. Préférez les arguments explicites color=, marker=, linestyle= pour un code lisible. Styles de ligne courants : '-' '--' ':' '-.'. Marqueurs courants : 'o' 's' '^' 'D' 'v' '+' 'x'.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 5, 20)
# format string: [color][marker][linestyle]
plt.plot(x, x, "r-")        # red solid line
plt.plot(x, x*2, "go--")    # green circles, dashed
plt.plot(x, x*3, "bs:")     # blue squares, dotted
plt.plot(x, x*4, "k^-.")    # black triangles, dash-dot

# explicit kwargs (clearer, recommended)
plt.plot(x, x*5, color="purple", marker="D",
         linestyle="-.", linewidth=2, markersize=6)

Couleurs

Matplotlib accepte de nombreux formats de couleurs : noms ('red'), chaînes hex ('#FF8800'), tuples RGB(A), noms Tableau ('tab:blue'), références au cycle ('C0'..'C9') et niveaux de gris ('0.5'). 'C0' prend la première couleur du style courant, gardant les graphiques cohérents avec le cycle de couleurs.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 1, 30)
plt.plot(x, x, color="red")              # named color
plt.plot(x, x+0.2, color="#FF8800")      # hex RGB
plt.plot(x, x+0.4, color=(0.1, 0.8, 0.2))# RGB tuple 0-1
plt.plot(x, x+0.6, color="C0")           # cycle color 0
plt.plot(x, x+0.8, color="tab:purple")   # Tableau palette
# gray shorthand: a string of float in [0,1]
plt.plot(x, x+1.0, color="0.5")          # mid gray
plt.show()

Épaisseur, alpha et zorder

linewidth contrôle l'épaisseur du trait (défaut 1.5). alpha règle la transparence, essentielle quand les courbes se superposent pour voir ce qui est dessous. zorder contrôle l'empilement — les valeurs plus élevées sont dessinées après (au-dessus). Le zorder par défaut est 2 pour les lignes, 1 pour les patches.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
# alpha = transparency (0 invisible, 1 opaque)
# zorder = draw order; higher draws on top
plt.fill_between(x, np.sin(x), alpha=0.3, zorder=1)
plt.plot(x, np.sin(x), linewidth=2, zorder=2)
plt.plot(x, np.cos(x), linewidth=4, alpha=0.7, zorder=3)
plt.show()

Tracés en escalier

plt.step() trace des fonctions en escalier utiles pour les signaux numériques et données discrètes ; where contrôle où monte l'escalier ('pre', 'post', 'mid'). plt.stairs() (3.4+) est l'équivalent moderne qui prend les valeurs y et des bords de bins séparés, et s'intègre bien aux données type hist.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.arange(5)
y = [1, 3, 2, 4, 3]

# step: like plot but with horizontal/vertical steps
plt.step(x, y, where="post", label="post")
plt.step(x, y + 1, where="mid", label="mid")
plt.step(x, y + 2, where="pre", label="pre")
plt.legend(title="where=")

# stairs (matplotlib 3.4+): step from explicit bin edges
plt.stairs([1, 2, 1], baseline=0)

plt.show()
03

Nuages de points

Nuage simple

plt.scatter(x, y) trace des points sans lignes de liaison. Il est plus lent que plt.plot(x, y, 'o') quand vous avez des dizaines de milliers de points, car scatter permet à chaque point d'avoir sa propre taille et couleur. Utilisez plt.plot avec un marqueur pour la vitesse maximale avec un style uniforme.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(0)
x = rng.random(50)
y = rng.random(50)

plt.scatter(x, y)
plt.title("Basic Scatter")
plt.xlabel("x")
plt.ylabel("y")
plt.axis("equal")   # equal aspect ratio
plt.show()

Taille et couleur des marqueurs

L'argument s est l'AIRE du marqueur en points carrés (pas le rayon), donc un s 4x plus grand ne fait que 2x le rayon. L'argument c (couleur) avec cmap associe un tableau numérique à une colormap. Utilisez alpha < 1 quand les points se superposent pour que la densité soit visible.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(1)
n = 50
x = rng.random(n)
y = rng.random(n)
sizes = rng.random(n) * 500     # area in points^2
colors = rng.random(n)          # mapped to colormap

plt.scatter(x, y, s=sizes, c=colors, cmap="viridis", alpha=0.6)
plt.colorbar(label="value")
plt.title("Bubble Chart")
plt.show()

Nuage avec colormap

Passer un tableau 1-D à c associe chaque point à une colormap ; plt.colorbar(sc) ajoute une barre de couleurs (passez la valeur de retour du scatter pour que la colorbar connaisse le mapping). vmin/vmax fixent la plage de la colormap ; sans eux, matplotlib s'auto-ajuste au min/max des données.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)
c = x           # color by x value

sc = plt.scatter(x, y, c=c, cmap="plasma", vmin=0, vmax=10)
cb = plt.colorbar(sc)
cb.set_label("x position")
plt.title("Colored by x")
plt.show()

Transparence et sur-tracé

Avec beaucoup de points superposés, un nuage opaque masque la densité. Baissez alpha vers ~0.05 et réduisez le marqueur pour révéler la structure. Pour les très grands jeux de données (100k+ points), plt.hexbin ou plt.hist2d agrègent en bins et sont plus rapides et plus lisibles qu'un scatter brut.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(2)
n = 5000
x = rng.normal(0, 1, n)
y = rng.normal(0, 1, n)

# dense scatter: low alpha reveals density
plt.scatter(x, y, s=5, alpha=0.05, c="navy")
plt.title("Density via alpha")

# alternative: hexbin for very large datasets
plt.figure()
plt.hexbin(x, y, gridsize=40, cmap="Blues")
plt.colorbar(label="count")
plt.show()

Nuage catégoriel

Matplotlib n'a pas de strip plot intégré, donc scatter avec jitter manuel sur l'axe x est l'approche DIY standard. Pour des graphiques catégoriels de qualité publication (box, violin, swarm), préférez Seaborn, construit sur Matplotlib et s'intégrant au style plt.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(3)
groups = ["A", "B", "C"]
data = [rng.normal(0, 1, 30),
        rng.normal(2, 1, 30),
        rng.normal(1, 1.5, 30)]

for i, d in enumerate(data):
    # add jitter on x so points do not stack on one line
    jitter = rng.uniform(-0.1, 0.1, len(d))
    plt.scatter(np.full(len(d), i) + jitter, d, label=groups[i])

plt.xticks(range(len(groups)), groups)
plt.legend()
plt.show()
04

Diagrammes en barres

Barres verticales

plt.bar(x, height) dessine des barres verticales ; x peut être des chaînes (catégoriel). Le BarContainer retourné permet d'annoter ou recolorer des barres individuelles. La boucle avec plt.text() étiquette chaque barre — ajustez ha/va ('center'/'bottom') et l'offset y pour que les étiquettes se posent juste au-dessus de la barre.

matplotlib
import matplotlib.pyplot as plt

categories = ["Apple", "Banana", "Cherry", "Date"]
values = [25, 40, 30, 15]

bars = plt.bar(categories, values, color="tab:blue", edgecolor="black")

# annotate each bar with its value
for bar, v in zip(bars, values):
    plt.text(bar.get_x() + bar.get_width()/2, v + 1,
             str(v), ha="center", va="bottom")

plt.title("Fruit Sales")
plt.ylabel("units sold")
plt.ylim(0, 50)
plt.show()

Barres horizontales

plt.barh(y, width) dessine des barres horizontales — idéal pour de longues étiquettes de catégories qui se chevaucheraient en vertical. Appelez ax.invert_yaxis() pour que le premier élément apparaisse en haut, comme on lit une liste. La largeur vaut par défaut 0.8.

matplotlib
import matplotlib.pyplot as plt

items = ["Reading", "Coding", "Sleep", "Exercise"]
hours = [2, 6, 8, 1]

plt.barh(items, hours, color="tab:green")
plt.xlabel("hours per day")
plt.title("Daily Activities")

# invert so the first item appears at the top
plt.gca().invert_yaxis()
plt.show()

Barres groupées

Les barres groupées placent deux séries (ou plus) côte à côte en décalant les positions x de la demi-largeur de barre. Le motif x +/- w/2 avec largeur w les colle. Utilisez np.arange pour des positions x numériques pour que le calcul marche, puis réétiquetez avec plt.xticks.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

labels = ["Q1", "Q2", "Q3", "Q4"]
a = [20, 35, 30, 35]
b = [25, 32, 34, 20]
x = np.arange(len(labels))
w = 0.35

plt.bar(x - w/2, a, w, label="2023")
plt.bar(x + w/2, b, w, label="2024")
plt.xticks(x, labels)
plt.ylabel("revenue")
plt.legend()
plt.show()

Barres empilées

Les barres empilées utilisent l'argument bottom= : chaque série commence là où la précédente s'arrête. Pour plus de deux séries, accumulez : bottom = [m+w for m, w in zip(men, women)]. Elles montrent totaux et composition, mais rendent les séries du haut plus difficiles à comparer entre catégories.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

labels = ["A", "B", "C"]
men = [20, 35, 30]
women = [25, 32, 34]

plt.bar(labels, men, label="Men")
plt.bar(labels, women, bottom=men, label="Women")
plt.legend()
plt.title("Stacked Bars")
plt.show()

Barres avec barres d'erreur

L'argument yerr ajoute des barres d'erreur verticales ; capsize règle la longueur des extrémités. Passez error_kw pour styliser les barres. Pour des erreurs asymétriques, passez yerr=[lower_errors, upper_errors]. Cela marche sur barh (xerr) et sur plt.errorbar aussi.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

labels = ["A", "B", "C"]
means = [20, 35, 30]
errors = [2, 4, 3]

plt.bar(labels, means, yerr=errors, capsize=6,
        color="tab:orange", edgecolor="black",
        error_kw={"ecolor": "black", "linewidth": 1.5})
plt.title("Bar with Error Bars")
plt.ylabel("mean value")
plt.show()
05

Histogrammes

Histogramme simple

plt.hist(x) regroupe les données en bins et dessine des barres. bins peut être un entier (nombre de bins) ou une séquence de bords explicites. Par défaut il retourne des effectifs, donc l'axe y est la fréquence. La valeur de retour est (counts, bin_edges, patches), utilisable pour personnaliser davantage.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(0)
data = rng.normal(0, 1, 1000)

plt.hist(data, bins=30)
plt.title("Histogram")
plt.xlabel("value")
plt.ylabel("frequency")
plt.show()

Choisir les bins

Le choix des bins change radicalement l'aspect d'un histogramme. 'auto' utilise le maximum des règles de Sturges et Freedman-Diaconis — un défaut raisonnable. Passez un tableau de bords explicite pour un contrôle total et des bins comparables entre jeux de données. Trop peu de bins masque la structure ; trop nombreux ajoute du bruit.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(1)
data = rng.normal(0, 1, 1000)

# auto bin selection (Freedman-Diaconis, Sturges, etc.)
plt.hist(data, bins="auto", alpha=0.5, label="auto")
plt.hist(data, bins=10, alpha=0.5, label="10 bins")
plt.hist(data, bins=np.arange(-4, 4, 0.25),
         alpha=0.5, label="0.25 width")
plt.legend()
plt.show()

Plusieurs histogrammes

Des histogrammes superposés exigent alpha < 1 pour voir les deux distributions ; utilisez des couleurs distinctes. Pour plus de deux groupes, stacked=True évite l'encombrement mais complique la comparaison. Envisagez kdeplot (Seaborn) pour des courbes de densité lisses qui se superposent mieux que des histogrammes.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(2)
a = rng.normal(0, 1, 1000)
b = rng.normal(1, 1.2, 1000)

plt.hist(a, bins=30, alpha=0.6, label="A", color="tab:blue")
plt.hist(b, bins=30, alpha=0.6, label="B", color="tab:orange")
plt.legend()
plt.show()

# stacked alternative
plt.figure()
plt.hist([a, b], bins=30, stacked=True, label=["A", "B"])
plt.legend()
plt.show()

Densité / normalisé

density=True divise les effectifs par (total * largeur de bin) pour que les aires des barres somment à 1, produisant une densité de probabilité. Cela rend les histogrammes comparables entre tailles d'échantillon et permet de superposer une PDF théorique. Utilisez weights= pour pondérer les échantillons.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(3)
data = rng.normal(0, 1, 1000)

# density=True normalizes the area to 1 (PDF)
plt.hist(data, bins=30, density=True, alpha=0.6)

# overlay the theoretical PDF
from scipy.stats import norm
xs = np.linspace(-4, 4, 200)
plt.plot(xs, norm.pdf(xs), "r-", lw=2)
plt.title("Normalized Histogram + PDF")
plt.show()

Histogramme 2D

plt.hist2d regroupe deux variables en grille 2-D et colore chaque cellule selon l'effectif — le cousin discret du scatter pour données denses. Pour une sortie plus lisse, utilisez plt.hexbin (bins hexagonaux). Les deux acceptent un cmap et retournent des valeurs transmissibles à colorbar.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(4)
x = rng.normal(0, 1, 10000)
y = x + rng.normal(0, 1, 10000)

plt.hist2d(x, y, bins=40, cmap="Blues")
plt.colorbar(label="count")
plt.title("2D Histogram")
plt.xlabel("x")
plt.ylabel("y")
plt.show()
06

Diagrammes circulaires

Camembert simple

plt.pie(x, labels) dessine un camembert à partir des valeurs de x. autopct formate les étiquettes de pourcentage (chaîne printf ou fonction). startangle pivote le départ du premier secteur. Faites toujours plt.axis('equal') pour que le camembert soit un vrai cercle et non une ellipse.

matplotlib
import matplotlib.pyplot as plt

labels = ["Rent", "Food", "Transport", "Fun"]
sizes = [1200, 600, 300, 400]

plt.pie(sizes, labels=labels, autopct="%1.1f%%", startangle=90)
plt.title("Monthly Budget")
plt.axis("equal")   # circle, not ellipse
plt.show()

Explode et ombres

explode est un tuple de même longueur que les tailles ; chaque valeur décale ce secteur vers l'extérieur depuis le centre (0 = aucun décalage). shadow=True ajoute une ombre portée pour la profondeur. Utilisez explode avec parcimonie pour mettre en valeur une part — tout exploser donne un rendu brouillon.

matplotlib
import matplotlib.pyplot as plt

labels = ["A", "B", "C", "D"]
sizes = [30, 25, 25, 20]
explode = (0, 0.1, 0, 0)   # pull the 2nd wedge out

plt.pie(sizes, labels=labels, explode=explode,
        shadow=True, autopct="%1.0f%%",
        startangle=140)
plt.title("Exploded Pie")
plt.show()

Diagramme en anneau

Un anneau (donut) est un camembert avec un trou : réglez wedgeprops={'width': 0.4} pour dessiner des anneaux au lieu de secteurs pleins. Le trou central peut recevoir un résumé via plt.text(0, 0, ...). Les anneaux se lisent généralement mieux que les camemberts : la longueur d'arc encode mieux la valeur que l'angle.

matplotlib
import matplotlib.pyplot as plt

labels = ["A", "B", "C"]
sizes = [40, 35, 25]

wedges, texts = plt.pie(sizes, labels=labels,
                        wedgeprops=dict(width=0.4, edgecolor="w"))
plt.title("Donut Chart")
# add center text
plt.text(0, 0, "Total\n100", ha="center", va="center", fontsize=14)
plt.show()

Pourcentages et angle de départ

autopct peut être une fonction qui reçoit le pourcentage et retourne une chaîne, permettant d'afficher à la fois pourcentage et effectif absolu. startangle + counterclock=False contrôlent la direction des secteurs (départ en haut, sens horaire — l'ordre de lecture conventionnel). pctdistance positionne les étiquettes de pourcentage.

matplotlib
import matplotlib.pyplot as plt

labels = ["North", "South", "East", "West"]
sizes = [32, 24, 28, 16]
colors = ["#4C72B0", "#DD8452", "#55A868", "#C44E52"]

plt.pie(sizes, labels=labels, colors=colors,
        autopct=lambda p: f"{p:.1f}%\n({p*sum(sizes)/100:.0f})",
        startangle=90, counterclock=False,
        pctdistance=0.75)
plt.show()

Camembert imbriqué (concentrique)

Deux appels plt.pie avec radius et width différents créent des anneaux concentriques, un simple « sunburst ». L'anneau externe montre généralement les catégories de premier niveau et l'anneau interne leur détail. Gardez un rayon interne plus petit et ajoutez edgecolor='w' pour séparer visuellement les secteurs.

matplotlib
import matplotlib.pyplot as plt

# outer ring: regions, inner ring: sub-categories
outer = [40, 30, 30]
inner = [20, 20, 15, 15, 25, 5]
outer_labels = ["A", "B", "C"]
inner_labels = ["A1", "A2", "B1", "B2", "C1", "C2"]

plt.pie(outer, labels=outer_labels, radius=1.0,
        wedgeprops=dict(width=0.3, edgecolor="w"))
plt.pie(inner, labels=inner_labels, radius=0.7,
        wedgeprops=dict(width=0.3, edgecolor="w"))
plt.title("Nested Pie")
plt.show()
07

Subplots et mise en page

plt.subplot

plt.subplot(rows, cols, index) sélectionne les axes (indexés à partir de 1) dans une grille — la façon héritée à la MATLAB. L'index va de gauche à droite, de haut en bas. Il modifie les « axes courants », donc les appels plt suivants y dessinent. Préférez plt.subplots() pour du nouveau code ; plus propre et retourne de vrais objets Axes.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 5, 50)

# subplot(nrows, ncols, index)  -- 1-indexed!
plt.subplot(2, 2, 1)
plt.plot(x, x)

plt.subplot(2, 2, 2)
plt.plot(x, x**2)

plt.subplot(2, 2, 3)
plt.plot(x, x**3)

plt.subplot(2, 2, 4)
plt.plot(x, np.sin(x))

plt.tight_layout()
plt.show()

plt.subplots

plt.subplots(nrows, ncols) retourne (fig, axes) où axes est un tableau NumPy d'Axes — indexez-le comme axes[row, col]. sharex/sharey alignent les graduations et économisent l'espace. fig.suptitle() met un titre au niveau de la figure au-dessus de tous les subplots. Faites toujours plt.tight_layout() pour éviter le chevauchement des étiquettes.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

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

# one figure, 2x2 grid of Axes, shared x and y
fig, axes = plt.subplots(2, 2, figsize=(8, 6),
                         sharex=True, sharey=True)

axes[0, 0].plot(x, np.sin(x)); axes[0, 0].set_title("sin")
axes[0, 1].plot(x, np.cos(x)); axes[0, 1].set_title("cos")
axes[1, 0].plot(x, np.tan(x)); axes[1, 0].set_title("tan")
axes[1, 1].plot(x, -np.sin(x)); axes[1, 1].set_title("-sin")

fig.suptitle("Trig Family")
plt.tight_layout()
plt.show()

GridSpec

GridSpec donne un contrôle total sur la taille des subplots — vous pouvez fusionner des cellules par slicing (gs[0, :] = toute la ligne, gs[1:, 2] = colonne droite haute). Utilisez width_ratios/height_ratios pour des colonnes/lignes de tailles inégales. C'est l'outil standard pour les tableaux de bord complexes.

matplotlib
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec

fig = plt.figure(figsize=(8, 6))
gs = gridspec.GridSpec(3, 3, figure=fig)

ax1 = fig.add_subplot(gs[0, :])     # full top row
ax2 = fig.add_subplot(gs[1, :2])    # middle, left 2 cols
ax3 = fig.add_subplot(gs[1:, 2])    # right, spans 2 rows
ax4 = fig.add_subplot(gs[2, 0:2])   # bottom-left

ax1.set_title("wide top")
ax3.set_title("tall right")
plt.tight_layout()
plt.show()

Partage d'axes

sharex=True (ou sharey=True) lie les axes pour que le déplacement/zoom de l'un mette à jour les autres — parfait pour des séries temporelles empilées. Il masque aussi les graduations redondantes des axes internes. Les groupes partagés sont accessibles via ax.get_shared_x_axes() ; retirez un axe du groupe pour le découpler.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)

ax1.plot(x, np.sin(x))
ax2.plot(x, np.cos(x))

# zooming on one now zooms both
ax1.set_xlim(0, 5)
# decouple later if needed
# ax2.get_shared_x_axes().remove(ax2)

fig.suptitle("Shared x-axis")
plt.show()

Tight layout et constrained

tight_layout() ajuste l'espacement une fois pour éviter le chevauchement des étiquettes, mais ignore fig.suptitle — passez rect pour réserver l'espace. layout='constrained' (ou fig=Figure(layout='constrained')) est l'alternative moderne qui recalcule à chaque tracé, gère suptitle et colorbars correctement, et est recommandée pour du nouveau code.

matplotlib
import matplotlib.pyplot as plt

# tight_layout: simple, adjusts subplot spacing
fig, axes = plt.subplots(2, 2)
for ax in axes.flat:
    ax.set_xlabel("x label")
    ax.set_ylabel("y label")
    ax.set_title("a title")
fig.suptitle("tight_layout")
plt.tight_layout()
# leave room for suptitle
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()

# constrained_layout: recomputes on every draw (more robust)
fig, axes = plt.subplots(2, 2, layout="constrained")
fig.suptitle("constrained_layout")
plt.show()
08

Légendes et annotations

Légende simple

plt.legend() collecte les labels de chaque artiste tracé. loc règle la position dans les axes ('upper right', 'lower left', 'best', ...). Pour une légende externe, combinez bbox_to_anchor=(x, y) (coordonnées en fraction d'axes) avec loc pour ancrer ce coin de la boîte de légende à ce point.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 1, 30)
plt.plot(x, x, label="linear")
plt.plot(x, x**2, label="quadratic")
plt.plot(x, x**3, label="cubic")
plt.legend()
plt.show()

# legend outside the axes
plt.figure()
plt.plot(x, x, label="linear")
plt.plot(x, x**2, label="quadratic")
plt.legend(loc="upper left", bbox_to_anchor=(1, 1))
plt.tight_layout()
plt.show()

Position et colonnes de la légende

ncol répartit les entrées de légende en plusieurs colonnes — utile avec beaucoup de labels courts. frameon/framealpha/fancybox contrôlent l'apparence de la boîte. title ajoute un en-tête. Pour un rendu sans bordure, réglez frameon=False ; souvent plus propre dans les publications.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 1, 30)
for i in range(1, 6):
    plt.plot(x, x**i, label=f"x^{i}")

plt.legend(loc="upper center", ncol=3, fontsize=9,
           frameon=True, framealpha=0.9,
           title="Powers", title_fontsize=10)
plt.title("Custom Legend")
plt.show()

Annoter des points

ax.annotate(text, xy, xytext) place le texte à xytext et (optionnellement) dessine une flèche vers xy. xy est en coordonnées de données par défaut. arrowprops est un dict de style de flèche ; arrowstyle='->' est le plus courant. annotate est bien plus flexible que plt.text pour les callouts.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)
plt.plot(x, y)

# mark and label the maximum
idx = np.argmax(y)
plt.annotate(f"max = {y[idx]:.2f}",
             xy=(x[idx], y[idx]),        # point to annotate
             xytext=(x[idx]-1, 0.5),     # text position
             arrowprops=dict(arrowstyle="->"))
plt.show()

Annoter avec des flèches

arrowprops stylise le connecteur : arrowstyle ('->', '-|>', '<->'), color, lw. connectionstyle courbe la flèche — 'arc3,rad=0.3' l'arrondit, 'angle3' fait un coude à angle droit, 'bar' ajoute une barre en T. Cela permet des callouts clairs qui contournent les données sans chevaucher les courbes.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-3, 3, 100)
plt.plot(x, x**3 - 3*x)

plt.annotate("local min", xy=(1, -2), xytext=(2, -10),
             arrowprops=dict(arrowstyle="->", color="red",
                             lw=2, connectionstyle="arc3,rad=0.3"))
plt.annotate("local max", xy=(-1, 2), xytext=(-3, 8),
             arrowprops=dict(arrowstyle="-|>", color="blue",
                             connectionstyle="angle3"))
plt.show()

Handles de légende personnalisés

Quand la légende par défaut (construite depuis les artistes tracés) ne convient pas, fabriquez vos propres handles avec Line2D, Patch ou Line2D-sans-données et passez handles= à legend(). C'est indispensable pour des légendes combinant lignes, patches et marqueurs scatter dans une même clé.

matplotlib
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from matplotlib.patches import Patch

plt.plot([1, 2, 3], [1, 4, 9], "o-", color="tab:blue")
plt.plot([1, 2, 3], [1, 8, 27], "s--", color="tab:orange")

custom = [
    Line2D([0], [0], color="tab:blue", marker="o", label="squared"),
    Line2D([0], [0], color="tab:orange", marker="s", ls="--", label="cubed"),
    Patch(facecolor="gray", label="reference band"),
]
plt.legend(handles=custom)
plt.show()
09

Styles, couleurs et rcParams

Styles intégrés

plt.style.use(name) applique un rendu prédéfini globalement ; plt.style.context(name) l'applique temporairement dans un bloc with. Styles populaires : 'ggplot', 'seaborn-v0_8-*', 'bmh', 'fivethirtyeight'. Les styles Seaborn ont été renommés avec le suffixe '-v0_8' dans Matplotlib 3.6+.

matplotlib
import matplotlib.pyplot as plt

# list all available styles
print(plt.style.available)

# use a style globally
plt.style.use("seaborn-v0_8-whitegrid")

# or as a context manager (temporary)
with plt.style.context("dark_background"):
    plt.figure()
    plt.plot([1, 2, 3], [1, 4, 9])
    plt.title("dark")
    plt.show()

plt.plot([1, 2, 3], [9, 4, 1])
plt.title("default again")
plt.show()

Colormaps

Les colormaps se répartissent en trois familles : séquentielles (viridis, plasma) pour des données ordonnées 0..N, divergentes (coolwarm, RdBu) pour des données avec un point médian significatif (avec vmin/vmax centrés sur 0), et qualitatives (Set2, tab10) pour des catégories distinctes. Préférez les maps perceptuellement uniformes comme viridis — sûres pour le daltonisme et lisibles à l'impression.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

# sequential, diverging, qualitative
for cmap in ["viridis", "plasma", "coolwarm", "RdBu", "Set2"]:
    plt.scatter(x, y, c=x, cmap=cmap, label=cmap)
    plt.colorbar(label=cmap)
    plt.title(cmap)
    plt.show()

Cycle de couleurs personnalisé

axes.prop_cycle (un objet cycler) définit la séquence de propriétés parcourue à mesure que vous ajoutez des courbes. On peut cycler color, linestyle, marker et plus — combinez cycler(color=[...]) + cycler(linestyle=[...]) pour avancer les deux simultanément. Chaque graphique reçoit ainsi une palette cohérente et « de marque ».

matplotlib
import matplotlib.pyplot as plt
from cycler import cycler

# set the default color cycle for new axes
plt.rcParams["axes.prop_cycle"] = cycler(
    color=["#e41a1c", "#377eb8", "#4daf4a", "#984ea3", "#ff7f00"])

for i in range(1, 6):
    plt.plot([0, 1, 2], [i]*3, label=f"line {i}", lw=4)

plt.legend()
plt.title("Custom Cycle")
plt.show()

rcParams

rcParams est le dictionnaire de configuration maître contrôlant chaque défaut — taille de figure, DPI, polices, épaisseurs de ligne, grille, options savefig. Réglez les valeurs une fois en haut du script pour une sortie cohérente. plt.rcParams.update({...}) en règle plusieurs d'un coup. Utilisez mpl.rcParamsFile ou un fichier matplotlibrc pour rendre les défauts permanents.

matplotlib
import matplotlib.pyplot as plt
import matplotlib as mpl

# read / set individual parameters
mpl.rcParams["figure.figsize"] = (8, 4)
mpl.rcParams["figure.dpi"] = 100
mpl.rcParams["font.size"] = 12
mpl.rcParams["axes.grid"] = True
mpl.rcParams["axes.grid.which"] = "both"
mpl.rcParams["savefig.bbox"] = "tight"

# update many at once
plt.rcParams.update({
    "axes.titlesize": "large",
    "axes.labelsize": "medium",
    "lines.linewidth": 2,
})

plt.plot([1, 2, 3])
plt.title("Configured Defaults")
plt.show()

Formats de couleurs

matplotlib.colors fournit la conversion (to_hex, to_rgb), des listes de couleurs nommées et la construction de colormaps. LinearSegmentedColormap.from_list construit une colormap continue à partir de quelques couleurs d'ancrage. Pour des maps catégorielles personnalisées, utilisez ListedColormap(['#aaa', '#bbb', ...]). Cela permet de coller exactement aux palettes de marque.

matplotlib
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

# all named colors
print(list(mcolors.CSS4_COLORS)[:5])

# convert between formats
print(mcolors.to_hex((0.1, 0.2, 0.5)))      # #1a3380
print(mcolors.to_rgb("#ff8800"))            # (1.0, 0.533, 0.0)

# make a custom colormap from a list of colors
cmap = mcolors.LinearSegmentedColormap.from_list(
    "rg", ["red", "yellow", "green"])
import numpy as np
plt.imshow(np.linspace(0, 1, 256).reshape(1, -1),
           cmap=cmap, aspect="auto")
plt.title("Custom Colormap")
plt.show()
10

Réglages des axes

Limites (xlim / ylim)

plt.xlim/plt.ylim (ou ax.set_xlim/ax.set_ylim) fixent la plage visible des données. Passer None laisse une limite en autoscale, ex. set_ylim(None, 5) ne fixe que le haut. plt.margins() ajoute une marge en fraction de la plage des données plutôt que des limites dures.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
plt.plot(x, np.sin(x))

# set explicit limits
plt.xlim(2, 8)
plt.ylim(-1.5, 1.5)

# or autoscale with margin
# plt.margins(x=0.05, y=0.1)

# query current limits
print(plt.xlim())   # (2.0, 8.0)
plt.show()

Graduations (ticks)

plt.xticks(positions) règle où apparaissent les graduations ; plt.xticks(positions, labels) règle aussi leur texte. Passez une liste vide pour tout masquer. Pour des axes numériques, laissez généralement MaxNLocator choisir automatiquement et ne surchargez que pour des axes catégoriels ou symboliques (comme les multiples de pi).

matplotlib
import matplotlib.pyplot as plt
import numpy as np

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

# set tick positions
plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi])

# set positions AND labels
plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi],
           ["0", "pi/2", "pi", "3pi/2", "2pi"])

# turn off ticks
# plt.xticks([])

plt.show()

Formatage des graduations

Le module ticker donne un contrôle précis : les Locators décident OÙ vont les graduations (MultipleLocator toutes les N unités, MaxNLocator jusqu'à N graduations, LogLocator pour les axes log) ; les Formatters décident du TEXTE du label (FormatStrFormatter façon printf, FuncFormatter fonction arbitraire). Utilisez les locators mineurs pour des grilles fines.

matplotlib
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import MultipleLocator, FormatStrFormatter, FuncFormatter

x = np.linspace(0, 5, 100)
plt.plot(x, x**2)

ax = plt.gca()
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.xaxis.set_minor_locator(MultipleLocator(0.25))
ax.yaxis.set_major_formatter(FormatStrFormatter("%.0f"))

# format with a function
ax.yaxis.set_major_formatter(
    FuncFormatter(lambda v, p: f"{v/1000:.1f}k"))

plt.show()

Échelle logarithmique

plt.xscale('log') / plt.yscale('log') basculent un axe en logarithmique — indispensable pour des données couvrant des ordres de grandeur. 'symlog' est une échelle log avec une région linéaire près de zéro pour afficher des valeurs négatives. Utilisez plt.grid(True, which='both') pour montrer les grilles majeures et mineures (espacées log).

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.logspace(0, 4, 50)   # 10^0 .. 10^4
plt.plot(x, x**2)

# log both axes
plt.xscale("log")
plt.yscale("log")

# symlog: log scale that handles negative/zero values
# plt.yscale("symlog", linthresh=1)

plt.title("Log-Log Plot")
plt.grid(True, which="both", ls="--", alpha=0.5)
plt.show()

Ratio d'aspect et spines

ax.set_aspect('equal') garantit une échelle égale pour que les cercles restent circulaires — critique en géométrie et cartographie. Les spines sont les lignes de bordure des axes ; masquer celles du haut/droite (« despining ») donne un look plus épuré popularisé par Seaborn. On peut aussi déplacer les spines à des positions de données arbitraires pour des axes en croix.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots()
theta = np.linspace(0, 2*np.pi, 100)
ax.plot(np.cos(theta), np.sin(theta))

# equal data units on x and y (a true circle)
ax.set_aspect("equal")

# hide the top and right spines
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)

# move the remaining spines to the center for a cross-hair
# ax.spines["left"].set_position(("data", 0))
# ax.spines["bottom"].set_position(("data", 0))

plt.show()
11

Texte et expressions mathématiques

Texte dans les axes

ax.text(x, y, s) place le texte en coordonnées de données par défaut. Passez transform=ax.transAxes pour des coordonnées en fraction d'axes (0,0 = bas-gauche, 1,1 = haut-droite), ce qui permet d'épingler un label dans un coin quelle que soit la plage des données. ha/va contrôlent l'alignement horizontal/vertical.

matplotlib
import matplotlib.pyplot as plt

plt.plot([0, 1], [0, 1])
# ax.text(x, y, s)  -- x, y in data coords
plt.text(0.5, 0.5, "center of plot", ha="center", va="center",
         fontsize=14, color="red", rotation=30)

# align to axes fraction instead of data coords
plt.text(0.02, 0.98, "top-left", transform=plt.gca().transAxes,
         ha="left", va="top", bbox=dict(boxstyle="round", fc="yellow"))
plt.show()

suptitle et figtext

fig.suptitle() ajoute un titre couvrant toute la figure (au-dessus de tous les subplots) ; réservez-lui de l'espace avec tight_layout(rect=[...]) ou utilisez layout='constrained'. fig.text(x, y, s) place du texte en coordonnées de fraction de figure (0,0 = bas-gauche de la figure), utile pour pieds de page et notes de source.

matplotlib
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2)
axes[0].plot([1, 2, 3])
axes[1].plot([3, 2, 1])

# figure-level title (above all axes)
fig.suptitle("Main Title", fontsize=16, fontweight="bold")

# arbitrary figure-coordinate text
fig.text(0.5, 0.01, "figure footer text", ha="center", fontsize=9)
plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()

Maths LaTeX (mathtext)

Matplotlib embarque un moteur mathtext : entourez les maths façon LaTeX de dollars ($...$) et utilisez des chaînes brutes (r"..."). Les commandes courantes marchent : \frac, \sum, \int, lettres grecques \alpha..\omega, exposants x^2, indices x_i. Aucune installation LaTeX externe n'est nécessaire. Utilisez des r-strings pour que les antislash survivent à Python.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

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

# mathtext: enclose LaTeX in dollar signs
plt.title(r"$\sin(x)$ vs $x$")
plt.xlabel(r"$x$ (radians)")
plt.ylabel(r"$\sin(x)$")

# fractions, sums, greek letters
plt.text(2, 0.5, r"$\frac{a}{b} + \sum_{i=1}^{n} x_i^2$")
plt.text(2, -0.5, r"$\alpha, \beta, \gamma, \pi, \infty$")
plt.show()

Propriétés du texte

Chaque objet texte accepte un riche ensemble de propriétés : fontsize, fontweight ('bold'), fontstyle ('italic'), family ('serif'/'sans-serif'/'monospace'), color et un dict bbox pour une boîte de fond. Les objets texte sont retournés, donc modifiables plus tard (utile en animations et mises à jour interactives).

matplotlib
import matplotlib.pyplot as plt

t = plt.text(0.5, 0.5, "Styled Text",
             fontsize=18, fontweight="bold",
             fontstyle="italic", family="serif",
             color="darkblue",
             bbox=dict(boxstyle="round,pad=0.5",
                       facecolor="lightyellow", edgecolor="black"))

# animate or update properties later
t.set_fontsize(24)
t.set_color("crimson")

plt.show()

Annotations (textcoords)

Le textcoords d'annotate contrôle comment xytext est interprété : 'data' (défaut, unités de données), 'offset points' (points relatifs à xy — idéal pour décaler un label d'un point), 'axes fraction' (0-1 sur les axes) ou 'figure fraction'. Mélanger les systèmes de coordonnées garde les callouts lisibles au zoom.

matplotlib
import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4], [1, 4, 2, 3])

# xy in data coords, xytext in points OFFSET from xy
plt.annotate("offset text", xy=(2, 4),
             xytext=(15, 15), textcoords="offset points",
             arrowprops=dict(arrowstyle="->"))

# xytext in axes fraction
plt.annotate("axes corner", xy=(2, 4),
             xytext=(0.8, 0.8), textcoords="axes fraction",
             arrowprops=dict(arrowstyle="-|>"))

plt.show()
12

Sauvegarde des figures

Bases de savefig

plt.savefig(path) écrit la figure courante dans un fichier. Crucial : appelez-le AVANT plt.show() — show() termine et peut fermer/vider la figure, donc sauvegarder ensuite produit un fichier vide. L'extension du fichier détermine automatiquement le format (.png, .pdf, .svg, .jpg).

matplotlib
import matplotlib.pyplot as plt

plt.plot([1, 2, 3], [4, 5, 2])

# save BEFORE plt.show() -- show() clears the figure
plt.savefig("plot.png")
plt.savefig("plot.pdf")
plt.show()

Formats

Choisissez le format selon l'usage : PNG pour écran/web, PDF ou SVG (vectoriel) pour l'impression et l'édition car ils s'agrandissent sans pixellisation, JPG seulement pour des images photo (il perd en netteté sur les lignes et le texte). Les formats vectoriels donnent aussi des fichiers bien plus petits pour des tracés à peu d'éléments. Passez format= pour ignorer l'extension.

matplotlib
import matplotlib.pyplot as plt

plt.plot([1, 2, 3], [1, 4, 9])

# raster formats (pixels)
plt.savefig("plot.png")          # lossless, default
plt.savefig("plot.jpg", quality=95)
plt.savefig("plot.tiff", dpi=200)

# vector formats (scale without pixelation)
plt.savefig("plot.pdf")          # best for publications
plt.savefig("plot.svg")          # editable in Inkscape/Illustrator

# explicit format override
plt.savefig("plot.dat", format="png")

DPI et résolution

Le DPI (points par pouce) règle la résolution de sortie raster : dimensions en pixels = figsize * dpi. 72-100 DPI suffisent à l'écran ; 300+ DPI sont requis pour l'impression. Sauvegardez en vectoriel (PDF/SVG) pour éviter tout souci de résolution. Réglez savefig.dpi dans rcParams pour une sortie haute résolution cohérente sur tout un script.

matplotlib
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(6, 4))
ax.plot([1, 2, 3], [1, 4, 9])

# dpi controls pixel density: width_px = figsize[0] * dpi
plt.savefig("low.png", dpi=72)     #  432 x 288 px
plt.savefig("high.png", dpi=300)   # 1800 x 1200 px

# set a global default DPI
plt.rcParams["savefig.dpi"] = 300
plt.savefig("global.png")

bbox_inches et pad

Par défaut savefig rogne au rectangle de la figure, ce qui peut couper labels et titres près du bord. bbox_inches='tight' élargit la zone sauvegardée pour inclure tous les artistes, puis pad_inches ajoute une petite marge autour. C'est presque toujours ce qu'on veut — réglez-le par défaut via rcParams['savefig.bbox']='tight'.

matplotlib
import matplotlib.pyplot as plt

plt.plot([1, 2, 3], [1, 4, 9])
plt.title("With Long Title That Might Be Cut Off")

# tight bbox trims whitespace and keeps labels inside
plt.savefig("tight.png", bbox_inches="tight", pad_inches=0.1)

# trim even more aggressively
plt.savefig("tighter.png", bbox_inches="tight", pad_inches=0)

# preview the tight bounding box
# bbox = plt.savefig("x.png", bbox_inches="tight")  # returns a Bbox

Transparent et facecolor

transparent=True rend le fond de figure transparent (canal alpha PNG) — idéal pour superposer des graphiques sur des slides ou pages web. facecolor règle la couleur du fond sauvegardé (elle remplace la couleur à l'écran). Le fond des axes se règle séparément via ax.set_facecolor(). Combinez les deux pour des designs en couches.

matplotlib
import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot([1, 2, 3], [1, 4, 9])
ax.set_facecolor("#f0f0f0")

# transparent background (alpha channel)
plt.savefig("transparent.png", transparent=True)

# explicit figure face color
plt.savefig("colored.png", facecolor="lightblue", edgecolor="none")

# control which elements are saved
plt.savefig("full.png", facecolor=fig.get_facecolor())
13

Graphiques 3D (mplot3d)

Axes 3D

Créez des axes 3D avec projection='3d' (via add_subplot ou subplot_kw dans subplots). Toutes les méthodes 2-D marchent plus celles spécifiques à z (set_zlabel, plot_surface, scatter, etc.). Le support 3D passe par le toolkit mplot3d, fourni avec Matplotlib sans installation supplémentaire.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()
# add a 3D axes via projection
ax = fig.add_subplot(projection="3d")

# or from subplots
# fig, ax = plt.subplots(subplot_kw={"projection": "3d"})

ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("3D Axes")

plt.show()

Nuage 3D

ax.scatter(x, y, z) sur des axes 3D place des points dans l'espace ; s et c marchent comme en scatter 2-D. Ajoutez fig.colorbar(sc) pour montrer le mapping de couleurs. Le nuage 3D excelle pour explorer des clusters, mais les graphiques 3D statiques peuvent masquer la profondeur — tournez interactivement ou encodez une dimension par la couleur.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(0)
n = 200
x = rng.normal(0, 1, n)
y = rng.normal(0, 1, n)
z = rng.normal(0, 1, n)
c = np.sqrt(x**2 + y**2 + z**2)

fig = plt.figure()
ax = fig.add_subplot(projection="3d")
sc = ax.scatter(x, y, z, c=c, cmap="viridis")
fig.colorbar(sc, label="distance from origin")
ax.set_title("3D Scatter")
plt.show()

Surface 3D

plot_surface(X, Y, Z) dessine une surface colorée ; X, Y, Z doivent être des tableaux 2-D de même forme produits par np.meshgrid. rstride/cstride contrôlent combien de points de grille sont sautés (plus bas = plus lisse mais plus lent). cmap colore selon Z ; ajoutez une colorbar (avec shrink pour l'adapter à une figure 3D).

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-5, 5, 80)
y = np.linspace(-5, 5, 80)
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

fig = plt.figure()
ax = fig.add_subplot(projection="3d")
surf = ax.plot_surface(X, Y, Z, cmap="coolwarm",
                       rstride=1, cstride=1,
                       linewidth=0, antialiased=True)
fig.colorbar(surf, shrink=0.5, aspect=10)
ax.set_title("3D Surface")
plt.show()

Wireframe et contour 3D

plot_wireframe ne dessine que les lignes de grille (plus léger qu'une surface pleine, bien pour montrer la structure). ax.contourf avec zdir='z' et offset projette des contours remplis sur un plan sous la surface — la classique visualisation « 2D sous la 3D ». Combinez surface + contours projetés pour des terrains riches.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-3, 3, 30)
y = np.linspace(-3, 3, 30)
X, Y = np.meshgrid(x, y)
Z = X * np.exp(-X**2 - Y**2)

fig = plt.figure()
ax = fig.add_subplot(projection="3d")
ax.plot_wireframe(X, Y, Z, color="black", rstride=1, cstride=1)
ax.set_title("Wireframe")

# 3D contour (filled) projected at the bottom
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
ax.contourf(X, Y, Z, zdir="z", offset=-0.5, cmap="viridis")
ax.set_title("3D Contour")
plt.show()

Barres 3D

ax.bar3d(x, y, z, dx, dy, dz) dessine des barres rectangulaires aux positions (x, y) partant de la base z avec largeurs dx, dy et hauteur dz. shade=True ajoute un éclairage pour un effet 3D. Aplatissez les tableaux de coordonnées avec .ravel() quand vous partez d'un meshgrid. Les barres 3D sont dures à lire — préférez des barres 2D groupées quand c'est possible.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()
ax = fig.add_subplot(projection="3d")

x = np.arange(3)
y = np.arange(3)
X, Y = np.meshgrid(x, y)
X, Y = X.ravel(), Y.ravel()
Z = np.zeros_like(X)
dz = np.array([1, 2, 3, 2, 3, 1, 3, 1, 2])

ax.bar3d(X, Y, Z, dx=0.6, dy=0.6, dz=dz,
         shade=True, color="tab:orange")
ax.set_title("3D Bar Chart")
plt.show()
14

Courbes de niveau (contour)

Lignes de niveau

plt.contour(X, Y, Z) trace les isolignes où Z est constant. X, Y viennent de meshgrid. levels règle le nombre (ou les valeurs exactes) de contours. plt.clabel(cs) étiquette chaque ligne avec sa valeur. Les contours en lignes sont précis mais sparses ; combinez avec contourf pour des régions remplies.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)

# line contours
cs = plt.contour(X, Y, Z, levels=15, colors="black", linewidths=0.8)
plt.clabel(cs, inline=True, fontsize=8)
plt.title("Contour Lines")
plt.colorbar(cs)
plt.show()

Contours remplis

plt.contourf (notez le « f ») remplit les régions entre niveaux de contour avec de la couleur, donnant un look de carte de chaleur lisse. Comme contour, il exige X, Y, Z sur grille. levels contrôle la résolution. contourf est la façon standard de visualiser des champs scalaires 2-D comme température, altitude ou densité de probabilité.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-2, 2, 100)
y = np.linspace(-2, 2, 100)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2

cf = plt.contourf(X, Y, Z, levels=20, cmap="viridis")
plt.colorbar(cf, label="Z")
plt.title("Filled Contour")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

Étiqueter les contours (clabel)

plt.clabel(cs) annote les lignes de contour avec leur valeur Z ; inline=True coupe la ligne pour loger le label. fmt formate le nombre ('%.2f' ou une fonction). Passez levels=[...] pour n'étiqueter que certaines isolignes. Des contours étiquetés transmettent les valeurs exactes sans colorbar.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
Z = X * np.exp(-X**2 - Y**2)

cs = plt.contour(X, Y, Z, 10, colors="black")
plt.clabel(cs, inline=True, fontsize=9, fmt="%.2f")
# label only specific levels
# plt.clabel(cs, levels=[-0.1, 0, 0.1])
plt.title("Labeled Contours")
plt.show()

Barre de couleurs (colorbar)

plt.colorbar(mappable) ajoute une légende de couleurs — passez toujours la valeur de retour du contour/imshow/scatter pour qu'elle connaisse le mapping. set_label/set_ticks la personnalisent. En subplots, une colorbar peut voler de l'espace à un axe ; utilisez ax= ou fig.colorbar(mappable, ax=axes) pour contrôler le placement sur plusieurs axes.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 5, 100)
y = np.linspace(0, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) + np.cos(Y)

cf = plt.contourf(X, Y, Z, cmap="RdBu")

# basic colorbar
cb = plt.colorbar(cf)
cb.set_label("Z value")
cb.set_ticks([-2, -1, 0, 1, 2])

# place colorbar with specific size and padding
# cb = plt.colorbar(cf, fraction=0.046, pad=0.04)

plt.title("Colorbar Example")
plt.show()

meshgrid et griddata

Contour/contourf exigent des données sur une grille régulière. Pour des échantillons dispersés, utilisez scipy.interpolate.griddata pour interpoler sur un meshgrid (méthodes : 'linear', 'nearest', 'cubic'). np.mgrid[...] est un raccourci pratique de meshgrid sur une plage. Tracer les points d'origine par-dessus montre où les données sont clairsemées.

matplotlib
import matplotlib.pyplot as plt
import numpy as np
from scipy.interpolate import griddata

# scattered (x, y, z) samples
rng = np.random.default_rng(0)
pts = rng.uniform(-2, 2, (200, 2))
z = np.sin(pts[:,0]) * np.cos(pts[:,1])

# build a regular grid
grid_x, grid_y = np.mgrid[-2:2:100j, -2:2:100j]

# interpolate scattered data onto the grid
grid_z = griddata(pts, z, (grid_x, grid_y), method="cubic")

plt.contourf(grid_x, grid_y, grid_z, levels=20, cmap="plasma")
plt.scatter(pts[:,0], pts[:,1], c="white", s=5, alpha=0.5)
plt.colorbar(label="z")
plt.title("Scattered -> Grid -> Contour")
plt.show()
15

Affichage d'images (imshow)

Bases de imshow

plt.imshow(arr) affiche un tableau 2-D comme heatmap ou un tableau 3-D (H, W, 3) comme image RGB. Par défaut l'origine est en haut à gauche (origin='upper'), conforme aux conventions d'image — réglez origin='lower' pour des axes à la math. plt.axis('off') masque les graduations pour un affichage propre.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

# a 2D array is shown as a heatmap (color = value)
rng = np.random.default_rng(0)
img = rng.random((10, 10))

plt.imshow(img, cmap="viridis")
plt.colorbar(label="value")
plt.title("imshow of a 2D array")
plt.show()

# a 3D array (H, W, 3 or 4) is shown as an RGB(A) image
rgb = rng.integers(0, 256, (50, 50, 3), dtype=np.uint8)
plt.imshow(rgb)
plt.axis("off")
plt.title("RGB image")
plt.show()

Colormap et colorbar

extent=[xmin, xmax, ymin, max] mappe les pixels du tableau en coordonnées de données ; sans lui, imshow utilise les indices de pixels. origin='lower' met la ligne 0 en bas (convention math). aspect='auto' étire l'image pour remplir les axes ; le défaut 'equal' préserve des pixels carrés. Passez l'objet image à colorbar.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-3, 3, 200)
y = np.linspace(-3, 3, 200)
X, Y = np.meshgrid(x, y)
Z = np.sin(X**2 + Y**2) / (X**2 + Y**2 + 1)

im = plt.imshow(Z, extent=[-3, 3, -3, 3], origin="lower",
                cmap="RdBu", aspect="auto")
cb = plt.colorbar(im)
cb.set_label("intensity")
plt.title("imshow with extent")
plt.show()

Interpolation

interpolation contrôle le mélange des pixels à l'agrandissement : 'none'/'nearest' montre des blocs nets (bien pour du pixel brut), 'bilinear'/'bicubic' lissent entre pixels (bien pour des heatmaps). L'interpolation ne change que l'apparence, pas les données. Pour de petits tableaux, on veut souvent 'nearest' pour que chaque cellule reste visible.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(1)
small = rng.random((5, 5))

methods = ["none", "bilinear", "bicubic", "nearest"]
fig, axes = plt.subplots(1, 4, figsize=(12, 3))
for ax, m in zip(axes, methods):
    ax.imshow(small, interpolation=m, cmap="magma")
    ax.set_title(m)
    ax.axis("off")
plt.tight_layout()
plt.show()

vmin / vmax et norm

vmin/vmax fixent la plage de données mappée sur la colormap (écrêtage des valeurs extrêmes). Pour des mappings non linéaires, utilisez norm= : LogNorm pour des données sur plusieurs ordres de grandeur, TwoSlopeNorm pour centrer une map divergente sur un point médian significatif (ex. 0 pour des anomalies). norm et vmin/vmax s'excluent — ne passez qu'un seul.

matplotlib
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import LogNorm, TwoSlopeNorm

rng = np.random.default_rng(2)
Z = rng.random((50, 50)) * 1000 + 1

# clamp the colormap range
plt.imshow(Z, vmin=100, vmax=500, cmap="viridis")
plt.colorbar()
plt.title("clipped range")
plt.show()

# log-scaled colors
plt.imshow(Z, norm=LogNorm(vmin=1, vmax=1001), cmap="plasma")
plt.colorbar()
plt.title("log scale")
plt.show()

# diverging norm centered on a midpoint
# norm = TwoSlopeNorm(vmin=-1, vcenter=0, vmax=1)

Afficher une image depuis un fichier

mpimg.imread charge une image en tableau NumPy (float 0-1 pour PNG, 0-255 uint8 pour JPEG). plt.imshow l'affiche ; plt.imsave écrit un tableau sur disque. Les images RGB gardent leurs couleurs ; passez cmap='gray' pour les images monocanal. Note : PIL/pillow est plus capable pour un traitement d'image non trivial.

matplotlib
import matplotlib.pyplot as plt
import matplotlib.image as mpimg

# read an image file into a numpy array
img = mpimg.imread("photo.png")     # shape (H, W, 3) or (H, W, 4)
print(img.shape, img.dtype)

plt.imshow(img)
plt.axis("off")
plt.show()

# save the (possibly modified) array back to a file
# plt.imsave("out.png", img)

# drop the alpha channel if present
if img.shape[-1] == 4:
    img = img[..., :3]
16

Graphiques polaires

Axes polaires

projection='polar' transforme des axes en coordonnées polaires : x est l'angle (theta, radians) et y le rayon (r). Toutes les méthodes standard marchent mais opèrent en (theta, r). Les tracés polaires conviennent aux données directionnelles, fonctions périodiques et symétries circulaires. Réglez les graduations avec ax.set_thetagrids et ax.set_rgrids.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

# create a polar axes via projection
fig = plt.figure()
ax = fig.add_subplot(projection="polar")

# or from subplots
# fig, ax = plt.subplots(subplot_kw={"projection": "polar"})

theta = np.linspace(0, 2*np.pi, 100)
ax.plot(theta, np.sin(2*theta))
plt.show()

Courbe polaire

Sur un ax polaire, plot(theta, r) trace des courbes où theta est l'angle et r le rayon. set_rmax écrête la plage radiale ; set_rticks et set_thetagrids personnalisent les positions radiales/angulaires. Les courbes polaires montrent nettement les fonctions périodiques — une sinusoïde s'enroule en boucle fermée.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

theta = np.linspace(0, 2*np.pi, 200)

fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
ax.plot(theta, 1 + np.cos(theta), label="cardioid")
ax.plot(theta, np.abs(np.sin(2*theta)), label="rose")
ax.set_rmax(2.0)
ax.set_rticks([0.5, 1.0, 1.5])
ax.set_thetagrids([0, 90, 180, 270])
ax.legend(loc="upper right")
plt.show()

Radar / diagramme en toile

Un radar est une courbe polaire avec un axe par catégorie. L'astuce : ajoutez la première valeur/angle à la fin pour que la courbe se referme en boucle, et remplissez l'intérieur avec alpha. Réglez xticks sur les angles des catégories et étiquetez-les. Les radars comparent des profils multivariés mais peuvent induire en erreur — avec parcimonie.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

labels = ["Speed", "Power", "Range", "Comfort", "Price"]
values = [8, 7, 6, 5, 9]
N = len(labels)

# close the loop
angles = np.linspace(0, 2*np.pi, N, endpoint=False).tolist()
values += values[:1]
angles += angles[:1]

fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
ax.plot(angles, values, "o-")
ax.fill(angles, values, alpha=0.25)
ax.set_xticks(angles[:-1])
ax.set_xticklabels(labels)
ax.set_title("Radar Chart")
plt.show()

Barres polaires (rose)

Une rose (barres polaires) utilise ax.bar sur des axes polaires — chaque barre occupe un secteur angulaire. Utile pour des histogrammes directionnels comme la direction du vent ou la distribution des périodes de houle. Colorez les barres par rayon (comme montré) pour une dimension supplémentaire. bottom= peut empiler ou décaler les barres depuis le centre.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(0)
N = 12
theta = np.linspace(0, 2*np.pi, N, endpoint=False)
widths = 2*np.pi / N
radii = rng.uniform(1, 5, N)

fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
bars = ax.bar(theta, radii, width=widths, bottom=0,
              edgecolor="black")

# color bars by radius
for r, bar in zip(radii, bars):
    bar.set_facecolor(plt.cm.viridis(r / radii.max()))
ax.set_title("Rose Diagram")
plt.show()

Réglages polaires

set_theta_zero_location('N') place 0 radian en haut et set_theta_direction(-1) fait croître les angles en sens horaire — la convention de la boussole. set_rlabel_position(angle) déplace les étiquettes radiales à n'importe quel angle pour éviter le chevauchement avec les données. Ces réglages transforment un tracé polaire mathématique en tracé directionnel/boussole.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
ax.plot(np.linspace(0, 2*np.pi, 100), np.linspace(0, 1, 100))

# rotate 0 degrees to the top, go clockwise
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)

# radial limits and ticks
ax.set_rlim(0, 1.2)
ax.set_rticks([0.25, 0.5, 0.75, 1.0])
ax.set_rlabel_position(135)   # move radial labels out of the way

# label directions in degrees
ax.set_thetagrids([0, 90, 180, 270], labels=["E","N","W","S"])
plt.show()
17

Axes jumeaux (twin)

twinx (Y secondaire)

ax.twinx() crée de nouveaux axes partageant l'axe x mais avec leur propre axe y à droite — la façon standard de tracer deux grandeurs d'unités différentes (ex. température et humidité). Colorez chaque axe et ses graduations pour matcher la courbe afin que le lecteur sache quelle échelle correspond à quelle série.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)

fig, ax1 = plt.subplots()
ax1.plot(x, np.sin(x), "b-")
ax1.set_xlabel("x")
ax1.set_ylabel("sin(x)", color="b")
ax1.tick_params(axis="y", labelcolor="b")

# a second axes sharing the same x, with an independent y
ax2 = ax1.twinx()
ax2.plot(x, x*10, "r-")
ax2.set_ylabel("10*x", color="r")
ax2.tick_params(axis="y", labelcolor="r")

plt.title("twinx: two y-scales")
plt.show()

twiny (X secondaire)

ax.twiny() est le pendant horizontal : de nouveaux axes partageant l'axe y mais avec leur propre axe x en haut. Utilisez-le pour montrer les mêmes données sur deux échelles x (ex. mètres et pieds, ou temps en secondes et minutes). Même conseil de codage couleur — accordez la couleur de l'axe à sa courbe.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

y = np.linspace(0, 10, 50)

fig, ax1 = plt.subplots()
ax1.plot(np.exp(y), y, "g-")
ax1.set_ylabel("y")
ax1.set_xlabel("exp(y)", color="g")

# second axes sharing y, independent x on top
ax2 = ax1.twiny()
ax2.plot(y**2, y, "m-")
ax2.set_xlabel("y^2", color="m")

plt.title("twiny: two x-scales")
plt.show()

Graphique twin combiné

Quand on jumelle des axes, chaque jeu d'axes a sa propre légende. Pour une légende combinée unique, collectez les handles de lignes des deux axes dans une liste et appelez ax1.legend(lines, labels). C'est la façon idiomatique de garder une clé unique sur un graphique à double axe pour identifier les deux séries d'un coup d'œil.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

t = np.linspace(0, 5, 100)
temp_c = 20 + 5*np.sin(t)         # Celsius
humidity = 60 - 5*t               # percent

fig, ax1 = plt.subplots(figsize=(8, 4))

l1, = ax1.plot(t, temp_c, "r-o", label="Temperature (C)")
ax1.set_xlabel("time (s)")
ax1.set_ylabel("Temperature (C)", color="r")
ax1.tick_params(axis="y", labelcolor="r")

ax2 = ax1.twinx()
l2, = ax2.plot(t, humidity, "b-s", label="Humidity (%)")
ax2.set_ylabel("Humidity (%)", color="b")
ax2.tick_params(axis="y", labelcolor="b")

# combine legends from both axes
lines = [l1, l2]
ax1.legend(lines, [l.get_label() for l in lines], loc="upper right")
plt.title("Temperature & Humidity")
plt.show()

Despine des axes twin

Les axes jumeaux produisent naturellement une bordure supérieure doublée. Masquez les spines du haut des deux axes pour un rendu plus propre, et colorez les spines gauche/droite selon leur axe y respectif. Combiné avec des étiquettes colorées, cela signale clairement quelle échelle appartient à quelle courbe sans encombrer le graphique.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)

fig, ax1 = plt.subplots()
ax2 = ax1.twinx()

ax1.plot(x, np.sin(x), color="tab:blue")
ax2.plot(x, np.cos(x), color="tab:orange")

# remove the top spine so the two axes don't double-border
ax1.spines["top"].set_visible(False)
ax2.spines["top"].set_visible(False)

# color the spines to match their axes
ax1.spines["left"].set_color("tab:blue")
ax2.spines["right"].set_color("tab:orange")

plt.title("Clean Twin Axes")
plt.show()

Twin avec unités différentes

Parfois, pas besoin d'une deuxième série — juste un second axe avec des unités converties (km/miles, C/F). Créez twiny(), alignez les limites avec set_xlim, puis réglez manuellement xticks/xticklabels sur les valeurs converties. Cela annote une seule série de données avec deux systèmes d'unités.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

km = np.linspace(0, 100, 50)
mile = km * 0.621371

fig, ax1 = plt.subplots()
ax1.plot(km, np.sin(km/10), "tab:purple")
ax1.set_xlabel("distance")
ax1.set_ylabel("signal", color="tab:purple")

ax2 = ax1.twiny()
ax2.set_xlim(ax1.get_xlim())          # align x limits
# relabel the top ticks in miles
new_ticks = np.array([0, 25, 50, 75, 100])
ax2.set_xticks(new_ticks)
ax2.set_xticklabels([f"{m:.0f}" for m in new_ticks*0.621371])
ax2.set_xlabel("miles")
plt.show()
18

Barres d'erreur et zones remplies

errorbar

plt.errorbar(x, y, yerr) trace des points avec barres d'erreur verticales — le standard pour des données expérimentales avec incertitude. fmt est une chaîne de format de plot ('o-' = marqueurs + ligne). ecolor, elinewidth et capsize stylisent les barres. Utilisez xerr= pour des erreurs horizontales, ou les deux pour des incertitudes 2-D.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 5, 10)
y = np.exp(-x)
yerr = 0.1 + 0.1*x      # error grows with x

plt.errorbar(x, y, yerr=yerr, fmt="o-", color="tab:blue",
             ecolor="gray", elinewidth=1.5, capsize=4,
             markersize=6, label="exp(-x) +/- err")
plt.legend()
plt.title("Error Bar Plot")
plt.show()

Erreurs asymétriques

Pour des incertitudes asymétriques, passez yerr comme un tableau 2 x N : la ligne 0 est les erreurs basses (vers le bas) et la ligne 1 les erreurs hautes (vers le haut). Courant quand les erreurs sont asymétriques (ex. comptages de Poisson). Le même motif s'applique à xerr pour des incertitudes horizontales asymétriques.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.arange(5)
y = np.array([2, 3, 5, 4, 6])
# separate lower and upper errors (each a 1-D array)
yerr = [[0.5, 1, 0.8, 0.6, 1.2],   # lower
        [1.0, 0.8, 1.5, 1.0, 0.7]]  # upper

plt.errorbar(x, y, yerr=yerr, fmt="s", color="tab:green",
             capsize=5)
plt.title("Asymmetric Error Bars")
plt.show()

# horizontal asymmetric errors work the same way
# xerr = [[...lower...], [...upper...]]

fill_between

fill_between(x, y1, y2) ombrage la région entre deux courbes y — parfait pour intervalles de confiance, bandes d'erreur et plages. where= limite le remplissage là où un tableau booléen est True (utilisez interpolate=True si les courbes se croisent). alpha < 1 garde la courbe sous-jacente visible à travers la bande.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)
std = 0.2

plt.plot(x, y, "b-", label="mean")
# shade +/- one standard deviation
plt.fill_between(x, y - std, y + std, color="blue", alpha=0.2,
                 label="+/- 1 std")

# shade only where a condition holds
plt.fill_between(x, y, 0, where=(y > 0), color="green", alpha=0.2,
                 label="y > 0")
plt.legend()
plt.show()

stackplot

plt.stackplot(x, y1, y2, ...) empile plusieurs séries l'une sur l'autre, montrant totaux et composition sur un x continu (souvent le temps). Contrairement aux barres empilées, c'est pour des données continues. La hauteur totale est la somme de toutes les séries. Utilisez des couleurs distinctes avec alpha pour que les frontières entre couches restent claires.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

years = np.arange(2010, 2021)
a = np.array([10, 12, 14, 15, 17, 18, 20, 22, 23, 25, 27])
b = np.array([ 5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
c = np.array([ 3,  4,  4,  5,  6,  6,  7,  8,  8,  9, 10])

plt.stackplot(years, a, b, c, labels=["A", "B", "C"],
              colors=["#4C72B0", "#55A868", "#C44E52"], alpha=0.8)
plt.legend(loc="upper left")
plt.title("Stacked Area Chart")
plt.xlabel("year")
plt.ylabel("value")
plt.show()

fill (polygone)

plt.fill(x, y) ferme et ombrage un polygone arbitraire — utile pour mettre en valeur des régions ou ombrager sous une courbe. Pour ombrager sous une courbe, concaténez les x avec leur inverse et les y avec des zéros. Pour plusieurs régions remplies disjointes, passez des tableaux 2-D ou appelez fill plusieurs fois.

matplotlib
import matplotlib.pyplot as plt
import numpy as np

# fill a closed polygon defined by its vertices
x = [0, 1, 1, 0, 0]
y = [0, 0, 1, 1, 0]
plt.fill(x, y, color="tab:cyan", alpha=0.5)

# shade under a curve
xs = np.linspace(0, 2*np.pi, 100)
ys = np.sin(xs)
plt.fill(np.r_[xs, xs[::-1]],
         np.r_[ys, np.zeros_like(ys)],
         color="tab:orange", alpha=0.3)

plt.title("Filled Polygons")
plt.show()
19

Intégration Seaborn

Intro à Seaborn

Seaborn est une bibliothèque de tracé statistique de haut niveau bâtie sur Matplotlib : elle accepte des DataFrames pandas, gère groupement/agrégation, et apporte de meilleurs défauts. Chaque fonction Seaborn retourne des Axes (ou une Figure) Matplotlib, donc vous pouvez continuer à personnaliser avec plt/ax. Appelez sns.set_theme() une fois pour passer au style Seaborn.

matplotlib
# install seaborn
pip install seaborn

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# Seaborn is built ON matplotlib: any sns plot returns an Axes
# and accepts an ax= argument, so you can mix freely.

sns.set_theme()        # apply seaborn's default style
tips = sns.load_dataset("tips")

ax = sns.scatterplot(data=tips, x="total_bill", y="tip", hue="time")
ax.set_title("Tips dataset")
plt.show()

Styles Seaborn

sns.set_style règle le rendu des axes (grille, fond), set_context adapte polices/lignes au support de sortie ('paper', 'talk', 'poster'), et set_palette règle le cycle de couleurs. sns.despine() retire les spines du haut/droite. Tout cela compose un rendu par défaut soigné en une ou deux lignes.

matplotlib
import seaborn as sns
import matplotlib.pyplot as plt

# five built-in themes: darkgrid, whitegrid, dark, white, ticks
sns.set_style("whitegrid")
sns.set_context("notebook")   # paper, notebook, talk, poster

# set the color palette
sns.set_palette("Set2")

import numpy as np
for i in range(4):
    plt.plot(np.arange(10), np.arange(10)+i)
plt.title("Seaborn-styled")
plt.show()

# remove the top/right spines (despine) for a clean look
# sns.despine()

relplot (relationnel)

sns.relplot est l'interface au niveau figure pour les tracés relationnels : kind='scatter' (défaut) ou 'line'. col/row scindent les données en subplots (faceting) automatiquement — bien plus simple que des subplots manuels. Elle retourne un FacetGrid dont .fig et .axes permettent de retomber sur Matplotlib pour affiner titres et mise en page.

matplotlib
import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset("tips")

# scatter or line, faceted by a categorical variable
g = sns.relplot(data=tips, x="total_bill", y="tip",
                hue="smoker", style="time", col="day",
                kind="scatter", height=3, aspect=1.2)

g.fig.suptitle("Tips by day", y=1.03)
plt.show()

histplot et kdeplot

sns.histplot remplace le distplot déprécié : il trace des histogrammes et peut superposer une estimation de densité par noyau (kde=True). stat='density' normalise, et common_norm=False garde les groupes normalisés indépendamment. sns.kdeplot trace juste la courbe de densité lisse, utile pour comparer des distributions.

matplotlib
import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset("tips")

# histogram with an overlaid KDE (density curve)
sns.histplot(data=tips, x="total_bill", bins=20, kde=True,
             hue="time", stat="density", common_norm=False)
plt.title("Histogram + KDE")
plt.show()

# standalone KDE
plt.figure()
sns.kdeplot(data=tips, x="total_bill", hue="time", fill=True)
plt.show()

heatmap

sns.heatmap dessine une matrice colorée avec annotations de cellules optionnelles (annot=True). center=0 avec une cmap divergente (coolwarm) distingue visuellement corrélations positives/négatives. Il encapsule plt.imshow + plt.text + colorbar, économisant beaucoup de code répétitif pour matrices de corrélation et de confusion.

matplotlib
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# correlation matrix
tips = sns.load_dataset("tips")
num = tips.select_dtypes("number").drop(columns=["size"])
corr = num.corr()

sns.heatmap(corr, annot=True, cmap="coolwarm", center=0,
            vmin=-1, vmax=1, square=True,
            linewidths=0.5, fmt=".2f")
plt.title("Correlation Heatmap")
plt.show()

pairplot et violinplot

sns.pairplot crée une grille de nuages de points pour chaque paire de colonnes numériques, colorée par une catégorie (hue) — le moyen le plus rapide d'explorer les relations d'un nouveau jeu de données. sns.violinplot combine un box plot avec une estimation de densité, montrant la forme de la distribution par groupe. Les deux reposent sur du pur Matplotlib et se personnalisent davantage.

matplotlib
import seaborn as sns
import matplotlib.pyplot as plt

iris = sns.load_dataset("iris")

# scatter matrix: every numeric column vs every other
g = sns.pairplot(iris, hue="species", height=2.5)
g.fig.suptitle("Iris pairplot", y=1.01)
plt.show()

# violin plot: box + kernel density on each side
plt.figure()
sns.violinplot(data=iris, x="species", y="sepal_length",
               inner="quartile")
plt.show()
20

Interactif et animation

Widget Slider

matplotlib.widgets.Slider ajoute un curseur interactif. Créez des axes pour lui (souvent en bas de figure via plt.axes([left, bottom, width, height] en fraction de figure)), reliez un callback à on_changed, et mettez à jour vos données dedans. Appelez fig.canvas.draw_idle() pour rafraîchir. Nécessite un backend interactif (pas Agg).

matplotlib
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider
import numpy as np

fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.25)

x = np.linspace(0, 10, 500)
line, = ax.plot(x, np.sin(x))

# axes for the slider
ax_freq = plt.axes([0.2, 0.1, 0.6, 0.03])
slider = Slider(ax_freq, "freq", 0.1, 5.0, valinit=1.0)

def update(val):
    line.set_ydata(np.sin(slider.val * x))
    fig.canvas.draw_idle()

slider.on_changed(update)
plt.show()

Boutons

matplotlib.widgets.Button ajoute un bouton cliquable. Comme le slider, il a besoin de ses propres axes (positionnés en fraction de figure). Le callback reçoit un objet event qu'on ignore généralement. Combinez plusieurs widgets (sliders, boutons, checkboxes) pour construire des tableaux de bord d'exploration directement dans Matplotlib.

matplotlib
import matplotlib.pyplot as plt
from matplotlib.widgets import Button
import numpy as np

fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.2)
(ln,) = ax.plot(np.random.rand(10))

ax_btn = plt.axes([0.7, 0.05, 0.2, 0.075])
btn = Button(ax_btn, "Resample")

def reshuffle(event):
    ln.set_ydata(np.random.rand(10))
    fig.canvas.draw_idle()

btn.on_clicked(reshuffle)
plt.show()

CheckButtons

CheckButtons affiche une liste de cases à cocher. Le callback reçoit le texte du label basculé, ce qui permet d'agir dessus pour inverser la visibilité de chaque artiste. Utilisez-le pour laisser le spectateur activer/désactiver des séries. Comme pour tous les widgets, il faut un backend interactif et la fenêtre doit rester ouverte.

matplotlib
import matplotlib.pyplot as plt
from matplotlib.widgets import CheckButtons
import numpy as np

x = np.linspace(0, 5, 200)
l1, = plt.plot(x, np.sin(x), label="sin")
l2, = plt.plot(x, np.cos(x), label="cos")
plt.subplots_adjust(right=0.8)

rax = plt.axes([0.82, 0.4, 0.15, 0.2])
check = CheckButtons(rax, ["sin", "cos"], [True, True])

def toggle(label):
    if label == "sin": l1.set_visible(not l1.get_visible())
    if label == "cos": l2.set_visible(not l2.get_visible())
    plt.draw()

check.on_clicked(toggle)
plt.show()

Curseur et événements souris

mpl_connect relie des événements (button_press_event, motion_notify_event, key_press_event, scroll_event) à des callbacks. L'objet event porte event.xdata/event.ydata (coordonnées de données) et event.inaxes (quels axes, ou None). C'est la base des interactions personnalisées — réticules, clic-pour-annoter, outils de zoom sur mesure.

matplotlib
import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])

def on_click(event):
    if event.inaxes != ax:
        return
    print(f"clicked at x={event.xdata:.2f} y={event.ydata:.2f}")

def on_move(event):
    if event.inaxes == ax:
        ax.set_title(f"x={event.xdata:.2f}, y={event.ydata:.2f}")
        fig.canvas.draw_idle()

fig.canvas.mpl_connect("button_press_event", on_click)
fig.canvas.mpl_connect("motion_notify_event", on_move)
plt.show()

Animation (FuncAnimation)

FuncAnimation anime en appelant update(frame) à répétition. update doit retourner les artistes modifiés (en tuple) pour que blit=True ne redessine qu'eux, pour la vitesse. interval est le délai entre frames en ms. La sauvegarde exige un writer ('ffmpeg' pour mp4, 'pillow' pour gif). Gardez une référence à l'objet animation (ani) ou il est ramassé par le garbage collector et s'arrête.

matplotlib
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 200)
line, = ax.plot(x, np.sin(x))

def update(frame):
    line.set_ydata(np.sin(x + frame / 10.0))
    return line,

ani = animation.FuncAnimation(fig, update, frames=100,
                              interval=50, blit=True, repeat=True)
# save to a file (requires ffmpeg or pillow installed)
# ani.save("wave.mp4", writer="ffmpeg")
# ani.save("wave.gif", writer="pillow")
plt.show()

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.