matplotlib

À quoi ça sert

matplotlib sert à transformer des données en image depuis du code Python. Que tu sois en exploration dans Jupyter, en train de générer un rapport, ou en train d'afficher un graphique dans une appli Streamlit, c'est probablement matplotlib qui dessine en dessous.

Quelques cas typiques :

• Courbe — évolution d'une métrique dans le temps (loss d'entraînement, ventes mensuelles).
• Histogramme — distribution d'une variable (ages, notes, salaires).
• Scatter plot — corrélation entre deux variables (poids vs taille).
• Bar chart — comparaison entre catégories (ventes par produit).
• Heatmap / image — matrices de confusion, images en niveaux de gris, etc.

Un exemple d'usage

Reprenons le DataFrame de ventes de la fiche pandas : on veut tracer le total des ventes par mois.

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv("ventes.csv", parse_dates=["date"])
df["mois"] = df["date"].dt.to_period("M")
totaux = df.groupby("mois")["montant"].sum()

# Création de la figure et du graphique
fig, ax = plt.subplots(figsize=(10, 5))
ax.plot(totaux.index.astype(str), totaux.values, marker="o")
ax.set_title("Ventes mensuelles")
ax.set_xlabel("Mois")
ax.set_ylabel("Montant (€)")
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig("ventes.png", dpi=150)
plt.show()

Le pattern central à comprendre : on crée d'abord une figure (la « feuille de papier »), qui contient un ou plusieurs axes (les graphiques). Toutes les méthodes set_title, plot, scatter, etc. s'appellent sur un objet ax. C'est l'approche dite object-oriented, celle recommandée.

How-to : installer et utiliser matplotlib

1. Installer matplotlib

   Dépendance principale comme pandas (cf. UV) :

   bash Copier

   uv add matplotlib

   En Jupyter, les graphiques s'affichent automatiquement sous la cellule. En script Python pur, il faut plt.show() pour ouvrir la fenêtre, ou plt.savefig(...) pour écrire un fichier image.

2. Le pattern figure / axes

   plt.subplots() crée une figure et renvoie deux objets : la figure et les axes. Tout dessin se fait sur l'ax.

   python Copier

   import matplotlib.pyplot as plt
   
   # Un seul graphique
   fig, ax = plt.subplots(figsize=(8, 5))
   ax.plot([1, 2, 3], [4, 5, 2])
   plt.show()
   
   # Plusieurs graphiques côte à côte
   fig, axes = plt.subplots(1, 2, figsize=(12, 5))
   axes[0].plot(x, y1)
   axes[1].scatter(x, y2)
   plt.show()

   plt.plot() ou ax.plot() ?

   Tu verras les deux styles dans la doc. plt.plot() applique sur la figure courante (style « MATLAB »), pratique pour des graphiques rapides. ax.plot() est explicite sur quel axe on dessine. Privilégie ax.plot() dès que tu fais un script propre ou plusieurs sous-graphes.

3. Les graphiques les plus courants

   python Copier

   # Courbe
   ax.plot(x, y, label="série 1", color="steelblue")
   
   # Nuage de points
   ax.scatter(x, y, s=50, alpha=0.5)
   
   # Histogramme
   ax.hist(donnees, bins=30)
   
   # Barres
   ax.bar(categories, valeurs)
   ax.barh(categories, valeurs)         # horizontal
   
   # Boîte à moustaches
   ax.boxplot([groupe1, groupe2, groupe3])
   
   # Image / matrice (matrice de confusion par ex.)
   ax.imshow(matrice, cmap="Blues")

4. Titres, axes, légende

   python Copier

   ax.set_title("Mon graphique")
   ax.set_xlabel("Temps")
   ax.set_ylabel("Valeur")
   ax.set_xlim(0, 100)             # bornes de l'axe X
   ax.set_yscale("log")            # échelle log
   
   # Légende : il faut un label= sur chaque plot()
   ax.plot(x, y1, label="train")
   ax.plot(x, y2, label="validation")
   ax.legend()
   
   # Grille discrète
   ax.grid(True, alpha=0.3)

5. Couleurs, marqueurs, styles

   matplotlib accepte les couleurs en nom ("red"), en hex ("#3a86ff") ou par index ("C0", "C1"… qui suivent la palette par défaut).

   python Copier

   ax.plot(x, y,
           color="#3a86ff",
           linewidth=2,
           linestyle="--",         # solid, dashed, dotted
           marker="o",             # o, x, ^, s, ...
           markersize=6)
   
   # Changer le thème global
   plt.style.use("ggplot")        # ou seaborn, dark_background...

6. Sauvegarder et afficher

   python Copier

   # Ajuste les marges pour éviter que les labels soient coupés
   fig.tight_layout()
   
   # Sauver en PNG, SVG, PDF…
   fig.savefig("graph.png", dpi=150, bbox_inches="tight")
   
   # Afficher (script seulement, inutile en Jupyter)
   plt.show()
   
   # Libérer la mémoire après un usage en boucle
   plt.close(fig)

   savefig avant show, pas l'inverse

   Dans un script, plt.show() bloque jusqu'à fermeture de la fenêtre — et selon le backend, ferme aussi la figure. Si tu appelles savefig après, tu peux récupérer un PNG vide. Règle simple : savefig puis show.

7. Tracer directement depuis un DataFrame

   pandas a une API df.plot() qui s'appuie sur matplotlib en dessous — pratique pour des graphiques rapides en exploration :

   python Copier

   df.plot(x="date", y="montant", kind="line")
   df["montant"].hist(bins=30)
   df.plot.scatter(x="poids", y="taille")

Aide-mémoire

import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot(x, y)
ax.set_title("…"); ax.set_xlabel("…"); ax.set_ylabel("…")
fig.tight_layout(); fig.savefig("out.png", dpi=150)

ax.plot(x, y)                # courbe
ax.scatter(x, y)             # nuage
ax.hist(donnees, bins=30)    # histo
ax.bar(cat, val)             # barres
ax.boxplot([g1, g2])         # boîtes
ax.imshow(M, cmap="Blues")   # matrice

ax.legend(loc="best")
ax.grid(True, alpha=0.3)
ax.set_xlim(0, 100); ax.set_ylim(0, 1)
ax.tick_params(axis="x", rotation=45)
plt.style.use("ggplot")

matplotlib et le reste de l'écosystème

• pandas / Polars — fournissent les données. df.plot() en pandas est un raccourci direct sur matplotlib.
• Jupyter — affiche automatiquement les figures matplotlib sous chaque cellule. C'est l'environnement le plus naturel pour itérer sur un graphique.
• Streamlit — affiche une figure matplotlib via st.pyplot(fig). Idéal pour partager un graphique en dashboard sans passer par un export d'image.
• MLflow — logge une figure directement comme artifact de run avec mlflow.log_figure(fig, "loss.png"). Très utile pour suivre l'évolution de la loss ou tracer une matrice de confusion à chaque entraînement.

Pour aller plus loin

• Site officiel : matplotlib.org
• Galerie d'exemples (le meilleur point d'entrée) : matplotlib.org/stable/gallery
• Cheat sheets officielles : matplotlib.org/cheatsheets
• Tutoriel « pyplot » : matplotlib.org/stable/tutorials/pyplot.html