Matplotlib : Tout savoir sur la bibliothèque Python de Dataviz

Matplotlib est une bibliothèque Python open source permettant de créer des visualisations de données. Découvrez tout ce que vous devez savoir : définition, fonctionnement, difficultés, formations…

La visualisation de données est une étape clé de l’analyse de données. Après avoir collecté, stocké et analysé des données, il est essentiel de transformer les résultats de ces analyses en rapports et en visualisations graphiques.

Pour cause, le cerveau humain comprend plus rapidement un diagramme qu’une succession de statistiques sous forme de tableau. La  » DataViz  » permet donc de partager les résultats d’une analyse avec les équipes non-techniques d’une entreprise, et notamment ses dirigeants.

Qu’est-ce que Matplotlib ?

Matplotlib est une bibliothèque Python open source permettant de créer des visualisations de données. Découvrez tout ce que vous devez savoir : définition, usages, historique bref.

Matplotlib est une bibliothèque Python open source, initialement développée par le neurobiologiste John Hunter en 2002 pour visualiser les signaux électriques du cerveau de personnes épileptiques. Son objectif était de répliquer, avec Python, les capacités de tracé de MATLAB. Suite au décès de John Hunter en 2012, la bibliothèque a été améliorée par de nombreux contributeurs de la communauté open source et s’impose aujourd’hui comme l’alternative libre à MATLAB pour la data visualisation.

La visualisation de données est une étape clé de l’analyse. Elle transforme des tableaux et statistiques en graphiques lisibles pour partager des résultats avec des équipes non techniques et aider à la décision. C’est aussi une compétence essentielle dans une formation Data Scientist.

• Définition rapide : une bibliothèque complète pour produire des visualisations statiques, animées et interactives en Python, adaptées à la publication et à l’exploration (zoom, déplacement, mise à jour des figures).
• Usages : création de tracés, histogrammes, diagrammes en barres, secteurs et figures 3D en quelques lignes de code, pour l’analyse de données, la recherche scientifique, la finance et l’enseignement.
• Où l’utiliser : dans des scripts et shells Python, sur des serveurs d’applications web, dans des notebooks JupyterLab et au sein d’interfaces graphiques grâce à ses APIs.
• Points forts : personnalisation fine du style et de la mise en page, export vers de nombreux formats (PNG, SVG, PDF), compatibilité naturelle avec Python et NumPy.
• Écosystème : base de nombreuses bibliothèques tierces comme seaborn (statistiques), HoloViews et plotnine (interfaces de haut niveau), ou Cartopy (cartographie).

Comment installer Matplotlib et vérifier la compatibilité ?

Matplotlib est une bibliothèque Python open source pour créer des visualisations. Au 12 juin 2026, la version stable la plus récente est 3.11.0 et elle requiert Python 3.11 ou supérieur.

Prérequis et compatibilité

Élément	Compatibilité recommandée	Vérification
Python	3.11, 3.12, 3.13 ou 3.14	python --version ou python3 --version
pip	Dernière version	python -m pip --version
Conda (optionnel)	Anaconda ou Miniconda à jour	conda --version
Dépendances	Installées automatiquement avec Matplotlib	Voir la section Vérifier l’installation

Installation avec pip

1. Créer un environnement virtuel:

   python -m venv .venv
   # Windows
   .venv\Scripts\activate
   # macOS / Linux
   source .venv/bin/activate

2. Mettre pip à jour:

   python -m pip install -U pip

3. Installer Matplotlib:

   python -m pip install matplotlib

Installation avec conda

1. Créer et activer un environnement:

   conda create -n viz python=3.12 -y
   conda activate viz

2. Installer Matplotlib depuis conda-forge (souvent le plus à jour):

   conda install -c conda-forge matplotlib

Vérifier l’installation

1. Depuis le terminal:

   python -c "import matplotlib, matplotlib.pyplot as plt; \
   print(matplotlib.__version__); \
   plt.plot([0,1],[0,1]); \
   plt.savefig('test_matplotlib.png'); print('OK')"

   Attendu: la version s’affiche et un fichier test_matplotlib.png est créé.

2. Depuis Jupyter:

   import matplotlib, matplotlib.pyplot as plt
   print(matplotlib.__version__)
   %matplotlib inline
   plt.plot([0, 1], [0, 1])
   plt.title("Test Matplotlib")
   plt.show()

3. Vérifier le backend si besoin:

   import matplotlib as mpl
   print(mpl.get_backend())

Dépannage rapide

• Incompatibilité Python: si l’installation échoue, vérifiez que Python est en version 3.11 ou plus avec python --version.
• Conflits d’environnements: évitez de mélanger pip et conda dans le même environnement, utilisez soit l’un soit l’autre.
• Module introuvable: activez l’environnement avant d’exécuter le code (source .venv/bin/activate ou conda activate viz).
• Affichage sous serveur sans interface: en dernier recours, sauvegardez le graphique en image avec plt.savefig(...) pour valider le rendu.

Architecture de Matplotlib : Figure, Axes, Artists

Pour écrire un code propre et comprendre les exemples, il faut connaître les briques fondamentales. Dans Matplotlib, une figure est une illustration complète. Chaque tracé de cette figure est appelé un axe dans le langage courant, et correspond à un objet Axes. Les éléments visibles du tracé sont des Artists.

Élément	Rôle	À retenir
Figure	Conteneur global qui regroupe une ou plusieurs zones de tracé.	Gère la taille, la résolution, les titres globaux, la mise en page.
Axes	Zone de tracé avec un système de coordonnées.	Contient les données dessinées et des objets Axis pour les graduations.
Axis	Gestion d’un axe numérique ou catégoriel.	Responsable des ticks, étiquettes et limites sur x ou y.
Artists	Tous les objets dessinés.	Exemples courants : Line2D, Patch (barres, formes), Text, Image, collections.

Exemple minimal orienté objet : on crée une figure et un Axes, puis on ajoute des Artists via les méthodes de Axes.

Pyplot vs API orientée-objet : que choisir ?

Pyplot fournit une interface dite stateful : des fonctions comme plt.plot agissent sur la figure et l’axes « actifs ». L’API orientée objet manipule explicitement les objets Figure et Axes pour tracer et configurer.

Critère	Pyplot (stateful)	API orientée objet
Style de code	Rapide, proche de MATLAB, peu de variables.	Explicite : fig, ax, méthodes de Axes.
Apprentissage	Très accessible pour des essais rapides.	Légèrement plus verbeux au départ.
Lisibilité à grande échelle	Moins adapté aux scripts complexes.	Idéal pour projets, fonctions et tests.
Recommandation	Exploration ponctuelle, notebook rapide.	Production, multiples sous-graphiques, réutilisabilité.

Pratique : commencez souvent par fig, ax = plt.subplots(), puis utilisez ax.plot, ax.bar, ax.set(...). Évitez de mélanger les deux styles dans le même bloc de code.

Comment fonctionnent les backends de rendu ?

Un backend traduit vos Artists en pixels ou en vecteurs et gère éventuellement l’interaction. Certains backends sont interactifs pour l’affichage à l’écran, d’autres sont hors écran pour la génération de fichiers.

Backend	Type	Usage principal	Notes utiles
Agg	Hors écran	Export d’images raster de haute qualité.	Idéal pour PNG, automatisation et serveurs.
QtAgg	Interactif	Fenêtres interactives avec l’écosystème Qt.	Zoom, pan, sauvegarde depuis la fenêtre.
TkAgg	Interactif	Fenêtres interactives via Tkinter.	Souvent simple à installer sur de nombreux OS.
nbAgg	Interactif	Affichage interactif dans Jupyter Notebook.	Alternative au mode statique %matplotlib inline.

Communs en pratique : dans un notebook, utilisez %matplotlib inline pour des images statiques ou %matplotlib notebook pour l’interactif. Dans un script, laissez Matplotlib choisir un backend interactif installé, ou forcez un backend spécifique :

Comment organiser une figure avec subplots ?

1. Grille simple : plt.subplots(nrows, ncols) crée une grille régulière de Axes. Utilisez sharex/sharey pour aligner les axes.
2. Compositions avancées : GridSpec permet des fusions de cellules et des mises en page asymétriques.
3. Axes partagés : partagez échelles et ticks pour faciliter la comparaison visuelle.
4. Mise en page : layout="constrained" dans plt.subplots ou fig.tight_layout() ajuste les espacements pour éviter que titres et labels se chevauchent.

Cas concret : un graphique principal à gauche et deux graphiques plus petits empilés à droite.

Qu’est-ce que PyPlot ?

PyPlot est le sous-module matplotlib.pyplot de Matplotlib. Il propose une interface de traçage dite à état, inspirée de MATLAB, accessible via l’alias courant import matplotlib.pyplot as plt. En quelques lignes, vous créez des figures et des axes, puis vous appelez des fonctions comme plot, scatter, bar ou pie pour dessiner vos graphiques. Rappel utile depuis notre section sur les concepts : une figure est l’illustration complète, et chaque tracé se fait dans un axe qui vit à l’intérieur de cette figure.

• Créer figure et axes rapidement : plt.figure(), plt.subplots() pour obtenir fig et ax si besoin d’un contrôle fin.
• Tracer des données : plt.plot(x, y) pour des courbes, plt.scatter(x, y) pour des nuages de points, plt.bar(categories, valeurs) pour des barres, plt.hist(x) pour des histogrammes.
• Mettre en forme : plt.title(), plt.xlabel(), plt.ylabel(), plt.legend(), plt.grid(True), plt.xlim(), plt.ylim().
• Images et couleurs : plt.imshow(img), plt.colorbar().
• Styles et paramètres : plt.style.use("classic") ou ajustements via plt.rcParams.
• Exporter et afficher : plt.savefig("figure.png", dpi=300) pour PNG, SVG ou PDF, puis plt.show() pour afficher la fenêtre interactive avec zoom et déplacement.

Exemple minimal avec les fonctions trigonométriques vues plus haut :

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 6, 200)
plt.plot(x, np.sin(x), label="sinus")
plt.plot(x, np.cos(x), label="cosinus")
plt.title("Exemple PyPlot")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.grid(True)
# plt.savefig("courbes.png", dpi=300)  # exporter si besoin
plt.show()

Astuce : pour des mises en page complexes, préférez l’approche orientée objet avec fig, ax = plt.subplots() puis ax.plot(...). PyPlot reste idéal comme couche de raccourcis pour aller vite.

Quels graphiques peut-on créer avec Matplotlib ?

Avec Matplotlib, il est possible de créer des tracés, des histogrammes, des diagrammes à barre et tous types de graphiques en quelques lignes. Voici une vue pratique des principales familles de tracés pour explorer et présenter vos données.

• Tracés de base: courbes y=f(x), séries temporelles, nuages de points, diagrammes en tiges.
• Catégories: barres verticales et horizontales, barres empilées avec étiquettes et tri.
• Distributions: histogrammes, boîtes à moustaches, violons.
• Matrices et images: cartes de chaleur et affichage d’images.
• Incertitudes: barres d’erreur et zones de confiance.

Tracés de base (courbes, fonctions, scatter)

• Courbes et fonctions: plot() pour tracer y=f(x), comparer plusieurs séries et ajouter style, couleur et légende.
• Séries temporelles simples: plot() avec des dates en abscisse pour visualiser des tendances au fil du temps.
• Nuages de points: scatter() pour observer relations et regroupements, avec taille s et couleur c pour encoder d’autres variables.
• Diagrammes en tiges: stem() pour signaux discrets ou valeurs par indice.

Exemple parlant: tracer les fonctions sinus et cosinus sur un intervalle avec plot() illustre comment superposer plusieurs courbes, styliser les lignes et ajouter une légende.

Catégories (barres, barres empilées)

• Barres verticales: bar() pour comparer des catégories.
• Barres horizontales: barh() pour libeller plus lisiblement des catégories longues.
• Empilement: utiliser bottom avec bar() ou cumuler left avec barh() pour empiler plusieurs séries.
• Étiquettes: Axes.bar_label() pour afficher les valeurs sur les barres.
• Ordonnancement: trier les catégories avant l’affichage pour faciliter la lecture.

Bonnes pratiques: triez vos catégories par valeur décroissante, harmonisez les couleurs d’une même famille et ajoutez une légende claire. Pour l’empilement, vérifiez que la somme des segments reste lisible et, si besoin, affichez aussi les totaux.

Distributions (histogramme, box/violin)

• Histogramme: hist() pour la forme globale d’une distribution, avec contrôle des classes bins et de la densité.
• Boîte à moustaches: boxplot() pour médiane, quartiles et valeurs atypiques, utile pour comparer plusieurs groupes.
• Violons: violinplot() pour la densité et la symétrie, pertinent quand les distributions sont multimodales.

Cas d’usage: comparez la répartition d’une métrique avant et après une expérimentation. Combinez boxplot() pour résumer par groupe et hist() ou violinplot() pour détailler la forme de la distribution.

Matrices et images (heatmap, imshow)

Pour des données 2D maillées ou des images, plusieurs approches existent selon la structure et la taille des grilles. imshow() est idéal pour afficher des matrices denses ou des images. pcolormesh() convient mieux aux grilles rectangulaires avec résolution variable ou coordonnées explicites. matshow() est une commodité pour visualiser rapidement des matrices comme des corrélations ou des matrices de confusion.

• imshow(): affichage rapide d’une matrice ou d’une image, avec cmap, vmin/vmax et aspect.
• pcolormesh(): carte de chaleur sur maillage, utile si vos x et y ne sont pas des indices réguliers.
• matshow(): vue simplifiée pour matrices carrées, pratique pour les corrélations.

Incertitudes (errorbar)

Pour matérialiser la variabilité de mesures, utilisez errorbar() avec yerr et, si nécessaire, xerr. Les paramètres comme capsize, elinewidth ou le format fmt améliorent la lisibilité. Pour des intervalles de confiance continus autour d’une courbe moyenne, complétez avec une zone ombrée via fill_between().

Exemple: affichez la moyenne quotidienne d’un indicateur et ses écarts types avec errorbar(), puis mettez en évidence un intervalle de confiance à 95 % autour de la courbe grâce à fill_between(). Le lecteur perçoit immédiatement la tendance et l’incertitude.

Comment personnaliser l’apparence ?

Pour produire des visuels soignés avec Matplotlib, regroupez vos choix d’esthétique au même endroit : styles et rcParams pour les réglages globaux, palettes et colormaps pour la couleur, titres / légendes / annotations pour la lisibilité, échelles et axes pour le bon cadrage. Comme indiqué plus haut, vous pouvez améliorer l’aspect visuel en ajoutant un titre et des légendes, en choisissant le style et la couleur, en jouant sur la taille des figures et la disposition des sous-graphiques, en annotant librement, puis en sauvegardant l’image finale.

• Définir un style global et vos rcParams par défaut.
• Choisir une palette ou colormap adaptée aux données, régler l’alpha si besoin.
• Soigner titres, sous‑titres, légendes et annotations, éviter les chevauchements.
• Ajuster échelles, limites, ticks et grilles pour guider la lecture.
• Exporter proprement avec une résolution suffisante et un cadrage serré.

Quels styles et rcParams utiliser ?

plt.style applique un thème visuel en une ligne, utile pour harmoniser vos graphiques. Utilisez plt.style.use("ggplot"), "seaborn-v0_8", "bmh", "fivethirtyeight" ou "dark_background", et listez les styles disponibles avec plt.style.available. Pour des changements temporaires, préférez les contextes plt.style.context(...) ou matplotlib.rc_context(...). Les rcParams contrôlent finement l’esthétique globale, par exemple la taille des figures, les polices, la grille et l’export.

• Contexte global : mpl.rcParams.update({...}) pour fixer vos valeurs par défaut dans un projet.
• Contexte local : with plt.style.context("ggplot"): ou with mpl.rc_context(rc={...}): pour un bloc spécifique.
• Clés utiles :
  • figure.figsize, figure.dpi, constrained_layout.use pour des figures nettes et bien agencées.
  • font.family, font.size, axes.titlesize, axes.labelsize pour la typographie.
  • axes.grid, grid.linestyle, grid.alpha pour une grille discrète.
  • axes.prop_cycle pour définir votre cycle de couleurs par défaut.
  • savefig.dpi, savefig.bbox, savefig.transparent pour l’export.

Couleurs et colormaps : comment choisir ?

Adaptez la couleur au type de variable : séquentielle pour des quantités qui augmentent, divergente lorsque l’écart autour d’un point neutre compte, qualitative pour des catégories. Les colormaps perceptuellement uniformes comme viridis assurent une progression lisible et plus accessible. Ajustez la transparence avec alpha en cas de chevauchements, définissez un cycle de couleurs cohérent via axes.prop_cycle, et pensez au colorbar pour expliciter l’échelle. Pour des plages non linéaires, appliquez un norm adapté, par exemple LogNorm, TwoSlopeNorm ou BoundaryNorm.

Usage	Type	Exemples de colormaps / palettes	Conseils accessibilité
Quantités croissantes	Séquentielle	viridis, plasma, magma, inferno, Greys	Favoriser des colormaps perceptuelles, éviter les à‑coups de luminosité.
Écarts autour d’un centre	Divergente	coolwarm, RdBu, PuOr	Fixer un centre explicite avec TwoSlopeNorm(vcenter=0), équilibrer les extrêmes.
Catégories disjointes	Qualitative	tab10, tab20, Set2, Pastel1	Varier marqueurs et motifs, pas seulement la couleur, pour le daltonisme.
Densité / chaleur	Séquentielle	inferno, magma	Veiller au contraste sur fond clair ou sombre, éviter le saturé intégral.

Bon réflexe : éviter la palette arc‑en‑ciel historique jet, peu lisible et trompeuse, et préférer des options perceptuelles comme viridis ou cividis.

Titres, légendes, annotations : bonnes pratiques ?

• Titres : utiliser ax.set_title(..., pad=...) pour chaque sous‑graphe et fig.suptitle(...) pour le titre global, avec tailles cohérentes. Privilégier des intitulés courts et informatifs.
• Légendes : donner des label explicites lors du tracé, puis ax.legend(). Placer automatiquement avec loc="best" ou en dehors du cadre avec bbox_to_anchor et ncol pour les légendes larges. Alléger l’encadré via frameon=False ou framealpha.
• Annotations : ax.annotate("texte", xy=(...), xytext=(...), arrowprops={...}) pour pointer un élément, ax.text(..., bbox={...}) pour un cartouche lisible. Ajuster ha, va, fontsize, et alpha. Limiter le nombre d’annotations pour éviter la surcharge.
• Mise en page : activer constrained_layout=True lors de la création de la figure ou appeler plt.tight_layout() avant l’export pour éviter les chevauchements entre titres, labels, légendes et colorbars.
• Export et filigrane : sauvegarder en haute qualité via plt.savefig(..., dpi=300, bbox_inches="tight"). Si besoin, ajouter un tatouage numérique avec fig.text(..., alpha=0.3).

Échelles (log), axes et ticks : comment les régler ?

1. Choisir l’échelle adaptée : ax.set_xscale("log") ou "symlog" pour des ordres de grandeur, "logit" pour des probabilités. Éviter les zéros et valeurs négatives en log, filtrer ou décaler si nécessaire.
2. Définir les limites et le cadrage : ax.set_xlim(...), ax.set_ylim(...), ax.margins(x=..., y=...). Utiliser ax.set_aspect("equal") si les unités doivent être comparables, et ax.invert_yaxis() pour des classements.
3. Configurer les ticks :
   • Locators : MaxNLocator, MultipleLocator, LogLocator, AutoDateLocator, AutoMinorLocator.
   • Formatters : ScalarFormatter avec useMathText=True, PercentFormatter, StrMethodFormatter ou FuncFormatter pour un format sur‑mesure.
   • Lisibilité : rotation des labels si nécessaire et activation des minor ticks avec ax.minorticks_on().
4. Affiner la grille : ax.grid(True, which="major", axis="both", linestyle=":", alpha=0.3), et si utile which="minor". Garder une grille subtile pour ne pas dominer les données.
5. Finaliser l’export : harmoniser police et tailles, vérifier l’alignement des titres et légendes, puis savefig avec les options de cadrage et de transparence appropriées.

En appliquant ces réglages de manière systématique, vous obtenez des graphiques plus lisibles et directement réutilisables dans un rapport ou une présentation, sans retouche manuelle.

Peut-on faire du 3D et des animations ?

Oui. En plus de vos graphiques 2D, Matplotlib permet de créer des figures plus complexes en trois dimensions et des visualisations animées. C’est idéal pour expliquer une évolution, simuler un phénomène ou enrichir des tableaux de bord pédagogiques.

• 3D avec mplot3d: surfaces, nuages de points, courbes spatiales directement dans une figure Matplotlib.
• Animations: API matplotlib.animation pour créer des séquences temporelles fluides à partir de vos tracés.
• Interaction légère: sliders, boutons et sélecteurs avec matplotlib.widgets, utiles pour rejouer une animation ou ajuster un paramètre.
• Export: enregistrement de vos rendus 3D et animations dans des formats standards pour le web, la présentation ou la publication.

Quelles sont les limites du 3D mplot3d ?

mplot3d (Axes3D) est pratique pour un aperçu 3D rapide, cependant il s’appuie sur le moteur 2D de Matplotlib. Le rendu reste basique, les performances chutent avec de gros volumes de points et certaines scènes souffrent d’occlusions imparfaites. Pour des besoins 3D lourds ou interactifs, envisagez des bibliothèques spécialisées.

Point	Conséquence	Alternatives ou bonnes pratiques
Rendu logiciel 2D	Pas d’accélération GPU, lenteur sur de grands nuages ou maillages denses	Échantillonner les données, privilégier wireframe/contours, envisager VisPy ou Plotly pour WebGL
Occlusion et profondeur approximatives	Artefacts visuels quand des objets se chevauchent	Soigner l’angle de vue, utiliser la transparence et des marqueurs petits, passer à Mayavi ou Plotly si la scène est complexe
Style et éclairage limités	Pas d’ombres réalistes ni d’éclairage avancé	Coder la profondeur par une colormap, utiliser Mayavi/VTK pour un rendu scientifique plus riche
Interaction basique	Rotation et zoom simples, peu d’outils de pick 3D	Compléter avec des widgets Matplotlib, ou migrer vers une solution interactive dédiée
Export	PDF/SVG lourds, risques de fichiers volumineux	Exporter en PNG haute résolution pour les scènes denses, optimiser la taille de figure

Comment créer et exporter une animation ?

1. Préparer la figure et les artistes: créez votre figure et les objets graphiques à mettre à jour au fil des images.
2. Définir la fonction de mise à jour: une fonction update(frame) qui modifie les artistes en fonction de l’index d’image.
3. Choisir l’API d’animation:
   • FuncAnimation: calcule les images à la volée via update, le plus flexible pour séries temporelles ou simulations.
   • ArtistAnimation: assemble une liste d’images déjà générées, utile si vous avez pré-calculé chaque étape.
4. Optimiser le rendu: activez blit lorsque possible, réduisez le nombre d’éléments redessinés, ajustez interval et fps.
5. Exporter en vidéo MP4: installez FFmpeg puis enregistrez, par exemple anim.save(« animation.mp4″, writer= »ffmpeg », fps=30).
6. Exporter en GIF: utilisez PillowWriter ou ImageMagick, par exemple anim.save(« animation.gif », writer= »pillow », fps=15) pour un partage rapide.

En pratique: commencez par un exemple minimal avec FuncAnimation, vérifiez l’aperçu dans votre environnement (script ou notebook) puis exportez. Pour des animations longues, pré-calculer les données, limiter la taille des figures et choisir un fps raisonnable améliore nettement la taille du fichier et la fluidité.

Comment exporter ses figures (PNG, SVG, PDF) ?

Dans Matplotlib, l’export se fait avec savefig. Choisissez le format selon l’usage, puis réglez le DPI et la transparence si besoin. Exemple rapide :

Bon à savoir : l’article mentionne la possibilité de sauvegarder une image au format jpg dans Matplotlib. Le JPEG est pratique pour des photos, mais il ne gère pas la transparence et applique une compression avec pertes. Pour des graphiques avec texte et lignes fines, privilégiez PNG ou des formats vectoriels (SVG, PDF).

Format	Type	Transparence	Qualité au zoom	Poids moyen	Usages conseillés	Réglages utiles
PNG	Raster	Oui (alpha)	Dépend du DPI	Moyen à élevé	Web, slides, rapports bureautiques	dpi=150, 300, transparent=True, bbox_inches="tight"
SVG	Vectoriel	Oui	Infini	Faible à moyen (peut croître si beaucoup de points)	Web, icônes, schémas avec texte net	Polices bien gérées, parfait pour lignes/texte
PDF	Vectoriel	Oui	Infini	Faible à moyen	Presse, édition, impression de qualité	bbox_inches="tight", polices intégrées par défaut

Astuce performance : pour des nuages de points très denses, les formats vectoriels peuvent produire des fichiers lourds. Rasterisez seulement les couches coûteuses avec artist.set_rasterized(True) ou définissez un zorder de rasterisation sur l’axe afin de garder le texte et les axes en vectoriel.

DPI, transparence, vectoriel vs raster : que choisir ?

Contexte	Format recommandé	Réglages conseillés	Pourquoi
Web (article, blog)	PNG ou SVG	PNG : dpi=120, 150, 2× pour écrans rétina. SVG si supporté.	PNG rend bien sur la plupart des CMS, SVG garde un texte très net.
Slides (PowerPoint, Keynote)	PNG ou SVG	PNG : dpi=150, 200, transparent=True pour fond des slides.	PNG simple et robuste, SVG possible selon la compatibilité du logiciel.
Rapport bureautique à imprimer	PDF ou PNG	PDF vectoriel si possible. Sinon PNG : dpi=300.	PDF garantit des lignes nettes, PNG 300 dpi reste propre à l’impression.
Presse / édition professionnelle	PDF	Vectoriel, polices intégrées. La conversion couleur CMJN se fait en PAO.	Contrôle qualité, mise à l’échelle parfaite et gestion des polices.

Rappels pratiques :

• DPI ne s’applique qu’aux formats raster (PNG, JPG). Les formats vectoriels (PDF, SVG) ignorent le DPI au profit d’un rendu indépendant de la résolution.
• Transparence : utilisez transparent=True avec savefig. Non disponible en JPEG.
• Mise en page : bbox_inches="tight" recadre la figure pour éviter les marges inutiles. Vous pouvez aussi définir la taille avec fig.set_size_inches(w, h) avant l’export.

Sauvegarde en script, en notebook et en batch

• En script Python
  fig.savefig(...) avant ou après plt.show() fonctionne, mais en pratique on sauvegarde avant show() pour éviter tout problème de backend. Fermez ensuite pour libérer la mémoire : plt.close(fig).

  fig, ax = plt.subplots()
  # ... construction du graphique ...
  fig.savefig("plot.png", dpi=300, bbox_inches="tight")
  plt.close(fig)
  

• Dans un notebook Jupyter
  L’affichage est implicite après la cellule. Pour un export propre et reproductible, appelez explicitement fig.savefig(...). Pour un rendu net à l’écran, vous pouvez activer un affichage haute densité, puis exporter avec vos propres réglages.

  # Affichage dans le notebook et export fichier
  fig, ax = plt.subplots()
  ax.plot(x, y)
  fig.savefig("notebook.svg", bbox_inches="tight")  # vectoriel
  

• En batch / serveur sans écran (mode headless)
  Utilisez un backend non interactif si nécessaire :

  import matplotlib as mpl
  mpl.use("Agg")  # avant d'importer pyplot
  import matplotlib.pyplot as plt
  # Pas de plt.show() en batch
  plt.savefig("batch.pdf", bbox_inches="tight")
  

  Pensez à fermer les figures en fin de boucle et à fixer des valeurs globales si utile :

  import matplotlib as mpl
  mpl.rcParams["savefig.dpi"] = 300
  mpl.rcParams["savefig.transparent"] = True
  

Comment rendre ses graphiques interactifs (Jupyter, GUIs) ?

Matplotlib ne sert pas qu’à produire des images statiques, elle permet aussi de créer des figures interactives qui zooment, se déplacent, se mettent à jour et réagissent aux actions de l’utilisateur. Avec les APIs de Matplotlib, il est possible d’intégrer des graphiques à des applications d’interface graphique, et d’ajouter des contrôles comme des curseurs ou des boutons pour piloter le tracé en direct.

Backends interactifs (QtAgg, TkAgg, nbAgg) : quel mode choisir ?

Le backend détermine comment Matplotlib affiche et gère l’interaction. Choisissez-le selon votre environnement et votre besoin.

Contexte	Backend conseillé	Activation rapide	Atouts	Limites
Notebook Jupyter/JupyterLab	widget via ipympl, ou nbAgg (notebook classique)	%matplotlib widget ou %matplotlib notebook	Vraie interactivité dans la cellule, pan/zoom, callbacks, redimensionnement	Nécessite l’extension ipympl pour widget (pip install ipympl)
Application bureau PyQt/PySide	QtAgg	matplotlib.use("QtAgg") avant pyplot	Intégration native avec Qt, performances et widgets riches	Gestion de la boucle d’événements Qt requise
Application bureau Tkinter	TkAgg	matplotlib.use("TkAgg")	Simple à déployer, standard de Python	Moins flexible que Qt pour des interfaces complexes
Script local interactif	QtAgg ou TkAgg	Laisser Matplotlib choisir, ou forcer via matplotlib.use(...)	Fenêtre interactive avec barre d’outils (zoom, pan, enregistrement)	Dépendance au toolkit graphique installé
Serveur/headless	Agg (rendu hors écran), éventuellement WebAgg	MPLBACKEND=Agg ou matplotlib.use("Agg")	Génération d’images/PDF sans écran, stable en production	Pas d’interaction native, sauf via WebAgg côté navigateur

Bon réflexe dans Jupyter : commencez par %matplotlib widget pour une expérience fluide. En script ou appli, forcez le backend avant import matplotlib.pyplot as plt. Sur serveur, privilégiez Agg pour éviter toute dépendance à l’affichage.

Quels widgets et événements utiliser ?

• Contrôles Jupyter avec ipywidgets : créez des curseurs, sélecteurs et cases à cocher qui appellent votre fonction de mise à jour.
  • Exemple de base : from ipywidgets import interact; interact(update, a=(0,10), b=(0,1,0.1)) pour rafraîchir un tracé à chaque mouvement de curseur.
  • Combinez avec %matplotlib widget pour une figure réactive dans la cellule.

• Slider pour ajuster un paramètre en continu : slider.on_changed(update).
• Button pour déclencher une action : button.on_clicked(callback).
• CheckButtons et RadioButtons pour masquer/afficher des séries.
• Cursor, SpanSelector pour lire ou sélectionner des plages.

• Connexion : cid = fig.canvas.mpl_connect("button_press_event", on_click), "motion_notify_event", "key_press_event", etc.
• Pick events pour réagir au clic sur un objet : activer artist.set_picker(True) puis écouter "pick_event" afin d’identifier la série ou le point sélectionné.

• Mettre à jour les données d’un artiste existant (line.set_ydata, scatter.set_offsets) plutôt que de récréer le tracé.
• Utiliser le blitting quand c’est possible pour limiter le rendu.
• Échantillonner ou plafonner le nombre de points affichés pour garder l’interface fluide.

Intégration dans des applis (Tkinter/PyQt) : est-ce adapté ?

Pour des outils de bureau, l’intégration est robuste et documentée. En PyQt/PySide, on intègre une figure via FigureCanvasQTAgg et une NavigationToolbar2QT dans une fenêtre Qt. En Tkinter, on utilise FigureCanvasTkAgg et la barre d’outils équivalente. Cas d’usage typiques : visionneuses de données locales, tableaux de bord offline, supervision d’acquisition, applications de reporting internes.

Points d’attention : la boucle d’événements du toolkit doit rester réactive, évitez les calculs longs dans le thread UI (utilisez threads ou tâches asynchrones). Pour diffuser l’application, anticipez le packaging (par exemple PyInstaller) et les dépendances du backend. Pour des tableaux de bord web temps réel, privilégiez un rendu serveur avec Agg ou une solution orientée navigateur, et gardez Matplotlib pour le calcul et le rendu des figures.

Matplotlib, NumPy et Pandas

Dans la pratique, Matplotlib travaille au plus près de NumPy et de Pandas. Les tableaux NumPy sont la structure de données sur laquelle s’appuient les tracés, tandis que Pandas, bâti sur NumPy, expose une API de traçage pratique qui utilise Matplotlib sous le capot. Résultat : la souplesse de Matplotlib avec l’ergonomie de Pandas, idéal pour passer de l’exploration à la production. Cette bibliothèque est particulièrement utile pour les personnes travaillant avec Python ou NumPy.

• Données numériques en mémoire : vecteurs ou matrices NumPy, tracés directs via Matplotlib.
• Données tabulaires : Series.plot() et DataFrame.plot() de Pandas appellent Matplotlib automatiquement.
• Mêmes styles et paramètres globaux : vous appliquez les feuilles de style et rcParams Matplotlib aux graphiques créés depuis Pandas.
• Même objet de sortie : les appels Pandas retournent un matplotlib.axes.Axes, que vous affinez ensuite sans friction.

Comment tracer directement depuis Pandas ?

1. Charger vos données dans un DataFrame ou une Series : df = pd.read_csv(...).
2. Tracer en une ligne avec .plot() pour un aperçu immédiat : df.plot(kind="line"), df.plot(kind="bar"), df["col"].plot(kind="hist"), df.plot.scatter(x="x", y="y").
3. Appliquer un style Matplotlib pour un rendu cohérent : import matplotlib.pyplot as plt, puis plt.style.use("ggplot") ou un autre style, ce qui s’applique aussi aux tracés Pandas.
4. Récupérer l’axe et peaufiner avec l’API Matplotlib : ax = df.plot(...), puis ax.set_title(...), ax.set_ylabel(...), ax.grid(True).
5. Accélérer votre EDA : df.describe() pour les stats, df.hist(figsize=(...)) et df.boxplot() pour la distribution, pd.plotting.scatter_matrix(df) pour un diagnostic multivarié rapide.

Exemple minimal :

Quand préférer Seaborn ou d’autres bibliothèques ?

Utilisez Matplotlib quand vous avez besoin de contrôle fin, de compositions sur mesure ou d’intégration dans des applications. Préférez Seaborn pour des graphiques statistiques expressifs avec de bons réglages par défaut, plotnine si vous aimez la grammaire de graphiques à la ggplot2, et Altair pour une approche déclarative et des visuels interactifs adaptés à l’exploration et aux notebooks.

Besoin	Bibliothèque conseillée	Pourquoi
Contrôle pixel‑par‑pixel, figures complexes	Matplotlib	API bas niveau très flexible, écosystème riche
Statistiques, distributions, régressions rapides	Seaborn	Primitives statistiques, thèmes soignés, intégration DataFrame
Grammaire de graphiques “ggplot”	plotnine	Syntaxe déclarative de mappage esthétique
Exploration déclarative, interaction légère	Altair	Spécifications Vega‑Lite, interactions simples sans code JS

Quelles extensions explorer ?

• Cartopy : cartographie et projections géographiques, idéal pour des cartes thématiques.
• WCSAxes : axes en systèmes de coordonnées célestes pour l’astronomie.
• HoloViews : composition de visualisations et interactivité, en s’appuyant sur Matplotlib.
• plotnine : implémentation Python de la grammaire de graphiques de ggplot.
• DNA Features Viewer : visualisation de caractéristiques génomiques.

Ces briques complètent Matplotlib selon votre domaine, tout en conservant des objets et des habitudes de travail familiers.

Quelles sont les difficultés liées à Matplotlib ?

Matplotlib est puissant et très souple, pourtant certains pièges reviennent souvent. Transformons-les en une check-list de dépannage rapide, pour afficher vos graphiques, éviter les figures vides ou superposées, gagner en performance et harmoniser le style sans écrire des dizaines de lignes.

Le graphique ne s’affiche pas : que vérifier ?

• Appel à l’affichage: dans un script, terminez par plt.show(). Sans cet appel, la fenêtre peut ne jamais s’ouvrir, surtout si le programme se termine immédiatement.
• Backend interactif: vérifiez le backend actif avec import matplotlib as mpl; print(mpl.get_backend()). Pour une fenêtre interactive, utilisez un backend adapté à votre OS (par exemple QtAgg, TkAgg, MacOSX). Sur serveur ou environnement sans écran, préférez Agg puis plt.savefig(...) au lieu de show(). Évitez de changer de backend après import matplotlib.pyplot as plt.
• Blocage d’événements: un while True ou un traitement long peut empêcher la boucle d’événements d’afficher la figure. Solutions pratiques: plt.show(block=True), insérer ponctuellement plt.pause(0.01), ou exécuter les calculs avant l’affichage. En mode interactif, plt.ion() peut aider.
• Environnements Notebook: dans Jupyter, activez l’affichage intégré (%matplotlib inline) ou interactif (%matplotlib widget). Si vous utilisez VS Code ou IPython, assurez-vous que la sortie graphique est activée. À distance via SSH, sans transfert X, utilisez Agg et enregistrez vos images.
• Variables d’environnement: si MPLBACKEND force un backend incompatible, supprimez-la ou remplacez-la. Sur macOS, un backend non pris en charge par la version Python peut empêcher l’ouverture de la fenêtre.

Astuce pratique: si rien ne s’affiche, testez un script minimal contenant uniquement l’import, un petit plot, plt.title(...) et plt.show(). Si ce test fonctionne, le problème vient de votre logique applicative, du backend choisi ou d’un blocage d’événements.

Figures vides ou superposées : comment les éviter ?

• Utiliser l’API orientée objet: créez systématiquement la figure et les axes avec fig, ax = plt.subplots(), puis tracez sur ax (ax.plot(...), ax.scatter(...)). Mélanger les appels plt.* et ax.* accroît le risque d’écrire sur le mauvais axe.
• Nettoyage explicite: pour relancer un tracé dans une boucle, utilisez ax.cla() pour vider un axe, fig.clf() pour vider une figure, ou plt.close(fig) pour la fermer. plt.close("all") évite les accumulations de fenêtres.
• Réutilisation maîtrisée: réutilisez les mêmes objets fig et ax quand vous mettez à jour un graphique, au lieu de recréer des figures sans les fermer. Conservez des références claires, évitez plt.gca() qui peut récupérer un axe inattendu.
• Bon axe et bonnes limites: vérifiez que vous tracez bien sur l’axe désiré et que les données ne sont pas hors champ (ax.set_xlim/set_ylim). Des limites trop strictes donnent l’impression d’un tracé vide.
• Sous-graphiques: avec plt.subplots(nrows, ncols), adressez-vous au bon axs[i, j]. Une confusion d’index crée des zones vides ou des superpositions.

Astuce pratique: commencez par un gabarit court qui crée fig, ax = plt.subplots(), trace en appelant ax.plot(...), ajuste les limites si besoin, puis sauvegarde avec fig.savefig(...). Ajoutez ensuite la complexité étape par étape.

Performances sur grands jeux de données : quelles options ?

• Downsampling: sous-échantillonnez avant l’affichage (x[::n], y[::n]) ou utilisez markevery pour n’afficher qu’une partie des marqueurs. Afficher un million de points apporte rarement plus de lisibilité qu’en afficher dix mille bien choisis.
• Collections efficaces: pour de nombreuses lignes ou segments, utilisez LineCollection, PolyCollection ou PathCollection au lieu d’objets individuels. Les collections réduisent le surcoût Python.
• Rasterisation sélective: pour des sorties vectorielles, appliquez rasterized=True aux artistes très denses (par exemple un scatter massif), conservez le reste en vectoriel. Le fichier final reste léger et net.
• Transparence et style: la transparence élevée (alpha très faible) peut ralentir le rendu. Limitez-la, ou combinez-la avec la rasterisation. Le style plt.style.use("fast") désactive certaines options coûteuses et accélère l’affichage.
• Simplification des chemins: ajustez rcParams["path.simplify"] et rcParams["path.simplify_threshold"] pour réduire le nombre de segments tracés, surtout pour les longues courbes.
• Choisir le bon type de tracé: pour des nuages très denses, préférez hexbin ou une image agrégée (imshow) plutôt qu’un scatter point à point.

Astuce pratique: démarrez avec le style "fast", downsamplez les séries longues, puis réactivez progressivement les options esthétiques nécessaires. Pour la publication, appliquez la rasterisation sélective afin de garder des fichiers vectoriels compacts.

Esthétique par défaut et verbosité : quelles solutions ?

Les réglages par défaut sont sobres, et multiplier les plt.* peut devenir verbeux. Plusieurs approches permettent d’obtenir rapidement des graphiques propres et cohérents.

• Styles prêts à l’emploi: plt.style.use("ggplot"), "seaborn", "tableau-colorblind10", ou "fast" pour prototyper. Créez un style maison en partant d’un de ces profils.
• rcParams: définissez polices, tailles, couleurs et largeur de traits via matplotlib.rcParams ou un contexte temporaire avec plt.rc_context(...). Un fichier matplotlibrc dans votre projet impose des defaults partagés par toute l’équipe.
• Seaborn pour de bons defaults: seaborn.set_theme() applique un style moderne, une palette harmonisée et des échelles contextuelles, tout en restant compatible avec Matplotlib.
• Fonctions utilitaires: centralisez le look via une fonction interne (make_axes(), apply_theme(ax)) qui crée la figure, règle la grille, la taille, les polices, et applique les mêmes conventions partout.

Astuce pratique: figez vos choix dans un style et quelques utilitaires, vous gagnerez en lisibilité et en temps à chaque nouveau graphique.

Des exemples rapides à copier ?

Voici 6 snippets prêts à l’emploi pour tracer les graphiques les plus courants avec Matplotlib.

1. Ligne simple (évolution d’une série)

   import matplotlib.pyplot as plt
   
   x = [0, 1, 2, 3, 4]
   y = [0, 1, 4, 9, 16]
   
   plt.plot(x, y, marker="o")
   plt.title("Courbe simple")
   plt.xlabel("x"); plt.ylabel("y")
   plt.show()

2. Nuage de points (relation entre deux variables)

   import matplotlib.pyplot as plt
   import numpy as np
   
   np.random.seed(0)
   x = np.random.randn(200)
   y = 0.5 * x + 0.3 * np.random.randn(200)
   
   plt.scatter(x, y, alpha=0.7)
   plt.title("Nuage de points")
   plt.xlabel("x"); plt.ylabel("y")
   plt.show()

3. Histogramme (distribution d’une variable)

   import matplotlib.pyplot as plt
   import numpy as np
   
   data = np.random.randn(1000)
   
   plt.hist(data, bins=30, color="#4C72B0")
   plt.title("Histogramme")
   plt.xlabel("Valeurs"); plt.ylabel("Fréquence")
   plt.show()

4. Barres (comparaison par catégorie)

   import matplotlib.pyplot as plt
   
   labels = ["A", "B", "C", "D"]
   valeurs = [23, 17, 35, 29]
   
   plt.bar(labels, valeurs)
   plt.title("Diagramme en barres")
   plt.xlabel("Catégories"); plt.ylabel("Valeurs")
   plt.show()

5. Sous-graphiques (plusieurs tracés côte à côte)

   import matplotlib.pyplot as plt
   import numpy as np
   
   x = np.linspace(0, 2*np.pi, 200)
   fig, axes = plt.subplots(1, 2, figsize=(8, 3))
   
   axes[0].plot(x, np.sin(x)); axes[0].set_title("sin(x)")
   axes[1].plot(x, np.cos(x), color="orange"); axes[1].set_title("cos(x)")
   
   plt.tight_layout(); plt.show()

6. Camembert (répartition d’un total)

   import matplotlib.pyplot as plt
   
   parts = [40, 25, 20, 15]
   labels = ["Prod", "R&D", "Marketing", "Autres"]
   
   plt.pie(parts, labels=labels, autopct="%1.0f%%", startangle=90)
   plt.axis("equal"); plt.title("Répartition du budget")
   plt.show()

Comment se former à Matplotlib ?

Allez droit au but avec les ressources officielles, puis pratiquez en reproduisant des exemples. Une bonne progression consiste à lire un court guide de démarrage, à explorer la gallery, à suivre quelques tutoriels pas à pas, puis à consolider avec des fiches mémo et des bonnes pratiques.

• Installez Matplotlib et lancez un notebook ou un script simple pour tracer votre premier graphique.
• Reproduisez 3 à 5 exemples de la gallery pour vous familiariser avec les figures, axes, légendes et styles.
• Appliquez ces acquis à un petit jeu de données réel, puis exportez vos figures au format PNG, SVG ou PDF.
• Gardez sous la main une cheatsheet et adoptez l’API orientée objet pour des scripts propres et reproductibles.

Par où commencer dans la doc et la gallery ?

Voici les points d’entrée les plus utiles sur le site officiel de Matplotlib :

• Tutoriels officiels: parcours pas à pas pour les bases, les styles, les sous-graphiques et les annotations (rubrique Tutorials sur matplotlib.org).
• Gallery: centaines d’exemples classés par thème, avec code prêt à copier, pour apprendre par imitation et varier les types de tracés.
• User Guide et API: référence complète et recherchable pour comprendre les concepts (figure, axes, artistes) et les paramètres disponibles.
• Cheat Sheets officielles: aide-mémoire synthétiques pour les commandes et la personnalisation.
• Aide de la communauté: forum Discourse et balise Matplotlib sur Stack Overflow pour poser des questions et débloquer un point précis.

Astuce pratique: partez d’un exemple de la gallery, adaptez les données, puis ajoutez progressivement titres, labels, échelles et styles. Sauvegardez vos variantes dans un même notebook pour garder l’historique des essais.

Quels cheatsheets et bonnes pratiques suivre ?

Adoptez très tôt une façon de coder claire et stable. En synthèse :

• Privilégier l’API orientée objet: fig, ax = plt.subplots(); ax.plot(x, y); ax.set(xlabel="x", ylabel="y", title="Titre"); fig.savefig("figure.png"). Cette approche rend le code plus lisible et évite les effets d’état de pyplot.
• Organiser figures et axes: créez vos sous-graphiques avec plt.subplots(nrows, ncols, sharex=True, sharey=True). Activez une gestion automatique des marges via constrained_layout ou tight_layout() pour des espacements propres.
• Style et cohérence: utilisez plt.style.use("default") ou une feuille de style adaptée au contexte. Centralisez vos choix de police, tailles et couleurs avec matplotlib.rcParams ou un contexte temporaire mpl.rc_context(...) pour garder des rendus homogènes.
• Reproductibilité: fixez un seed aléatoire côté données, par exemple rng = np.random.default_rng(42). Conservez vos paramètres clés (taille de figure, DPI, palette) au même endroit pour pouvoir recréer exactement une figure.
• Lisibilité avant tout: légendez systématiquement axes et unités, utilisez des colormaps lisibles pour le daltonisme (par exemple viridis), et n’affichez que l’essentiel. Préférez les formats vectoriels (SVG, PDF) pour l’édition et l’impression.
• Export contrôlé: fig.savefig("plot.svg", bbox_inches="tight", dpi=300) selon l’usage. Dans des boucles, pensez à plt.close(fig) pour éviter de saturer la mémoire.

Gardez une cheatsheet à portée de main pour les méthodes d’axes les plus courantes, la personnalisation des ticks et légendes, ainsi que les options de sauvegarde. Revenez au User Guide lorsque vous explorez des tracés plus avancés ou interactifs.

Faut-il citer Matplotlib et quelle licence ?

La citation de Matplotlib n’est pas une obligation de la licence, toutefois l’équipe du projet recommande de l’indiquer dans toute publication scientifique ou technique où la bibliothèque a contribué aux résultats. Cela valorise le travail des mainteneurs et facilite la reproductibilité.

• Publications et mémoires : ajoutez une mention bibliographique du logiciel. Reprenez l’entrée prête à l’emploi fournie par le projet (page “Cite” ou fichier CITATION.cff), en précisant au minimum le nom du projet, la version, l’année et l’URL officielle.
• Rapports, slides, notebooks : une formule courte suffit, par exemple “Graphiques réalisés avec Matplotlib (version X.Y)” avec un lien vers la documentation.
• Licence : Matplotlib est publié sous une licence de type Python Software Foundation, compatible BSD. Elle autorise l’utilisation, la modification et la redistribution, y compris dans des projets commerciaux et open source, sous réserve de conserver les avis de copyright et le texte de la licence dans les redistributions.
• Où vérifier : consultez la documentation officielle pour la section “Cite”, la page PyPI pour le type de licence, et le fichier LICENSE du dépôt GitHub du projet.

Conclusion

Matplotlib est une bibliothèque Python open source puissante pour créer des visualisations claires et partagées par tous, des tracés simples aux graphiques 3D, dans des scripts, des notebooks et des applications. Vous avez vu comment elle s’est structurée autour d’objets figure et axes, comment la personnaliser finement, et comment exporter vos résultats pour les diffuser.

• Installation : installez-la en quelques secondes avec pip, puis importez pyplot pour tracer vos premiers graphiques dans un script ou un notebook.
• Concepts clés : une figure regroupe un ou plusieurs axes, vous placez vos données sur X et Y, puis vous utilisez des fonctions comme plot, scatter, bar ou pie. Les tracés en trois dimensions sont possibles.
• Personnalisation : ajoutez titres et légendes, choisissez styles et couleurs, gérez la taille des figures et la disposition des sous-graphiques, annotez librement, voire ajoutez un tatouage numérique.
• Écosystème : profitez d’outils tiers construits sur Matplotlib comme seaborn pour des graphiques statistiques ou Cartopy pour les cartes, et intégrez vos figures dans JupyterLab ou des interfaces graphiques.
• Export : enregistrez vos visuels en PNG, SVG, PDF ou JPG pour vos rapports et présentations.

Le mieux est maintenant de pratiquer : ouvrez un notebook, recréez le tracé sinus et cosinus, puis expérimentez styles, annotations et export. Pour aller plus vite et gagner en bonnes pratiques, suivez un parcours guidé.