Visualisation avec Matplotlib et seaborn

Matplotlib est la bibliothèque de tracé standard de Python ; pandas et seaborn l’utilisent tous deux pour dessiner. Par convention, elle est importée avec import matplotlib.pyplot as plt. Dans un notebook Jupyter, un graphique apparaît sous la cellule qui le dessine ; dans un script, plt.show() affiche les figures ouvertes et, dans un script normal, attend que leurs fenêtres soient fermées.

Une figure est le canevas entier : l’image affichée ou enregistrée. Une zone de tracé est un espace de tracé dans la figure, avec ses propres données, son titre, les libellés et les bornes de ses axes ; une figure peut en contenir plusieurs. Un axe est l’un des axes gradués d’une zone de tracé, l’axe des abscisses ou celui des ordonnées, avec ses graduations et leurs libellés. Chaque élément visible, comme une ligne, un marqueur, un texte ou une barre, est appelé objet graphique.

fig, ax = plt.subplots() crée une figure avec une zone de tracé et renvoie les deux objets. figsize=(width, height) définit les dimensions de la figure en pouces. Par défaut, elles sont de 6,4 × 4,8 pouces à 100 points par pouce : une figure par défaut mesure donc 640 × 480 pixels à l’écran ; plt.subplots(figsize=(8, 4)) crée une figure plus large et plus aplatie.

Matplotlib propose deux styles. Dans le style orienté objet, tu appelles des méthodes sur des objets explicites : ax.plot(...), ax.set_title(...). Dans le style pyplot, des fonctions comme plt.plot(...) et plt.title(...) agissent sur la zone de tracé « courante », généralement la dernière créée. Les deux produisent les mêmes graphiques ; le style orienté objet est plus clair dès qu’une figure comporte plusieurs zones de tracé ou que le code de tracé est placé dans une fonction. C’est donc celui qu’utilise ce cours.

Les deux styles utilisent des noms différents pour les mêmes paramètres : plt.title, plt.xlabel et plt.xlim correspondent à ax.set_title, ax.set_xlabel et ax.set_xlim. Une erreur fréquente consiste à écrire ax.title("Rainfall") : sur une zone de tracé, title est un attribut qui contient un objet texte ; l’appeler déclenche donc TypeError: 'Text' object is not callable. Utilise ax.set_title("Rainfall").

months = [1, 2, 3, 4, 5, 6]; temp_c = [3, 5, 9, 13, 17, 20], puis

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(months, temp_c)
ax.set_title("Mean monthly temperature")
ax.set_xlabel("Month")
ax.set_ylabel("Temperature (°C)")

.

Les appels de tracé ajoutent des éléments à une zone de tracé ; ils ne remplacent pas ceux qui s’y trouvent. Un second ax.plot(...) sur le même ax ajoute une deuxième courbe au même graphique. Pour obtenir un graphique distinct, crée une nouvelle figure avec un autre appel à plt.subplots(), ou trace sur une autre zone de tracé d’une figure à plusieurs panneaux.

pyplot garde ouvertes toutes les figures qu’il a créées jusqu’à leur fermeture avec plt.close(fig) ou plt.close("all"). Les figures ouvertes occupent de la mémoire et, lorsque plus de 20 figures sont ouvertes, Matplotlib émet un avertissement. Un code qui crée des figures dans une boucle doit fermer chaque figure après l’avoir enregistrée.

ax.plot(x, y) dessine des marqueurs ou des segments de droite qui relient les points dans l’ordre fourni. Un graphique en courbes convient à une grandeur mesurée selon une variable ordonnée comme le temps ou la distance. Avec un seul argument, ax.plot(y), les abscisses sont par défaut 0, 1, 2, ….

Comme les points sont reliés dans l’ordre fourni, des abscisses non triées produisent un zigzag qui traverse le graphique dans les deux sens. Pour x = [3, 1, 2], la ligne va de x = 3 à x = 1, puis repart vers x = 2. Trie d’abord les données selon x, par exemple avec df.sort_values("x").

Arguments de style : color (un nom comme "black" ou "tab:orange", ou un code hexadécimal comme "#1f77b4"), linestyle ("-" continu, "--" tirets, ":" pointillés, "-." tirets-points), linewidth, marker ("o" cercle, "s" carré, "^" triangle) et markersize. Une courte chaîne de format combine le marqueur et le style de ligne : ax.plot(x, y, "o--") dessine des cercles reliés par une ligne en tirets. Sans color, chaque nouvelle ligne prend la couleur suivante du cycle par défaut, qui commence par "tab:blue" et "tab:orange".

Attribue un label à chaque ligne et appelle ax.legend() pour afficher une légende :

ax.plot(months, north, marker="o", label="North")
ax.plot(months, coast, linestyle="--", label="Coast")
ax.legend()

. Si aucun objet graphique n’a de libellé, ax.legend() ne dessine rien et Matplotlib avertit qu’aucun objet graphique avec libellé n’a été trouvé.

ax.scatter(x, y) dessine un marqueur non relié par observation et convient pour représenter la relation entre deux variables quantitatives. Exemple : températures quotidiennes [12, 15, 18, 21, 24, 27, 30, 22] °C et nombres de locations de vélos [180, 220, 260, 310, 330, 360, 340, 250] ; ax.scatter(temp_c, rentals) montre que les locations augmentent globalement avec la température, et la corrélation entre les deux listes est d’environ 0,92.

Dans ax.scatter, s définit l’aire de chaque marqueur en points carrés ; la valeur par défaut est 36, soit l’aire d’un marqueur de 6 points de large. Doubler s double l’aire : la largeur du marqueur n’augmente donc que d’un facteur d’environ 1,4. s peut être un seul nombre ou une valeur par point, ce qui permet de représenter une troisième variable par la taille des marqueurs.

c colore les points : une couleur pour tous, ou un nombre par point associé à une couleur d’une palette comme cmap="viridis". Conserve l’objet renvoyé et ajoute une barre de couleurs : sc = ax.scatter(temp_c, rentals, c=rain_mm, cmap="viridis"); fig.colorbar(sc, ax=ax, label="Rain (mm)").

Lorsque de nombreux points se chevauchent, les zones denses deviennent des taches pleines qui masquent le nombre de points qu’elles contiennent. Réduis l’opacité avec alpha=0.3, utilise des marqueurs plus petits ou représente plutôt la densité, par exemple avec un graphique à classes hexagonales (df.plot.hexbin) ou un histogramme bidimensionnel.

ax.plot(x, y, "o"), avec un marqueur et sans ligne, dessine aussi des points. Cette méthode est plus rapide pour un très grand nombre de points, car tous les marqueurs ont la même taille et la même couleur. Utilise ax.scatter lorsque la taille ou la couleur doit varier d’un point à l’autre.

ax.bar(categories, heights) dessine une barre verticale par catégorie ; ax.barh(categories, widths) dessine des barres horizontales, qui laissent de la place aux noms de catégories longs. Lorsque les catégories sont des chaînes de caractères, Matplotlib les place à intervalles réguliers dans l’ordre fourni et les utilise comme libellés des graduations. Lorsqu’il s’agit de nombres, les barres sont placées à ces positions sur un axe numérique ordinaire.

Par défaut, les barres partent d’une ligne de base située à 0 : leur longueur représente donc leur valeur. L’argument width est mesuré dans les unités de l’axe des abscisses et vaut 0,8 par défaut. Les catégories représentées par des chaînes sont espacées d’une unité : la valeur par défaut laisse donc un espace de 0,2 entre les barres, et width=1 fait se toucher les barres voisines.

On a demandé à 200 personnes comment elles effectuaient habituellement leur trajet domicile-travail : voiture 84, bus 52, vélo 38, marche 26. ax.barh(["Car", "Bus", "Bike", "Walk"], [84, 52, 38, 26]) dessine quatre barres horizontales. Les proportions sont de 42 %, 26 %, 19 % et 13 %, soit 100 % au total.

ax.barh place la première catégorie en bas de l’axe, car l’axe des ordonnées croît vers le haut. Pour lire une liste classée à partir du haut, comme dans l’exemple des trajets domicile-travail, appelle ax.invert_yaxis() ou inverse à la fois les catégories et leurs valeurs avant le tracé, afin que chaque valeur reste associée à sa catégorie.

Les barres groupées placent plusieurs séries côte à côte dans chaque catégorie. Utilise des positions numériques et décale chaque série d’une demi-largeur de barre :

x = np.arange(3)
ax.bar(x - 0.2, north, width=0.4, label="North")
ax.bar(x + 0.2, coast, width=0.4, label="Coast")
ax.set_xticks(x, labels=["Jan", "Feb", "Mar"])
ax.legend()

. Les barres de North sont placées en −0,2, 0,8 et 1,8, celles de Coast en 0,2, 1,2 et 2,2, de part et d’autre de chaque graduation.

Les barres empilées représentent une deuxième série au-dessus de la première avec bottom= : ax.bar(days, car); ax.bar(days, bus, bottom=car). Si un jour compte 40 trajets en voiture et 25 en bus, le segment du bus va de 40 à 65 et la hauteur totale de la barre est de 65.

bars = ax.bar(...) renvoie un conteneur de barres ; ax.bar_label(bars) écrit chaque valeur à l’extrémité de sa barre. fmt contrôle le texte : fmt="%.1f" écrit 3,14 sous la forme « 3.1 », et fmt="{:.0f} km" l’écrit sous la forme « 3 km ».

Matplotlib dessine les barres dans l’ordre des données, et non par ordre de grandeur. Pour obtenir un diagramme classé, trie d’abord les valeurs, par exemple avec sorted() sur des paires ou sort_values() dans pandas. L’argument yerr= ajoute à chaque barre une barre d’erreur de longueur donnée, et ax.errorbar(x, y, yerr=...) fait de même pour des points.

Un diagramme en barres compare les valeurs de catégories distinctes : ses barres sont donc séparées par des espaces. Un histogramme, en revanche, montre la distribution d’une variable quantitative sur des intervalles adjacents, et ses barres se touchent. Représenter des mesures avec une barre par ligne de données produit un diagramme en barres de valeurs brutes, pas un histogramme.

Définis le texte avec ax.set_title("..."), ax.set_xlabel("...") et ax.set_ylabel("..."), ou en un seul appel : ax.set(title="Monthly rainfall", xlabel="Month", ylabel="Rainfall (mm)"). Indique l’unité dans le libellé de l’axe, par exemple « Précipitations (mm) » ou « Distance (km) », pour que chaque valeur graduée ait un sens.

Matplotlib choisit les bornes des axes à partir des données, en ajoutant une petite marge. Définis-les toi-même avec ax.set_xlim(1, 12) et ax.set_ylim(0, 120), ou fixe une seule borne avec ax.set_ylim(bottom=0). ax.set(xlim=(1, 12), ylim=(0, 120)) fait la même chose en un seul appel.

ax.set_xticks([1, 4, 7, 10]) choisit les positions des graduations, et ax.set_xticks([1, 2, 3], labels=["Jan", "Feb", "Mar"]) remplace aussi leurs libellés. Fais pivoter les libellés trop serrés avec ax.tick_params(axis="x", labelrotation=45). Les outils de formatage des graduations modifient la façon dont les valeurs sont écrites : ax.yaxis.set_major_formatter(PercentFormatter(xmax=1, decimals=0)), après importation de PercentFormatter depuis matplotlib.ticker, affiche la valeur 0,25 sous la forme « 25% ».

ax.set_yscale("log") place l’axe des ordonnées sur une échelle logarithmique, où des distances égales représentent des rapports égaux : l’écart de 10 à 100 a la même longueur que celui de 100 à 1 000. Cette échelle convient aux valeurs qui s’étendent sur plusieurs ordres de grandeur, comme les populations des villes. Un axe logarithmique ne peut pas représenter zéro ni les valeurs négatives.

ax.legend() place la légende là où elle recouvre le moins de points (loc="best", valeur par défaut pour la légende d’une zone de tracé). Choisis un emplacement avec loc="upper left", ajoute un titre avec title="Station" et répartis les éléments sur plusieurs colonnes avec ncols=2. ax.legend(bbox_to_anchor=(1.02, 1), loc="upper left") place la légende juste à l’extérieur du bord droit de la zone de tracé.

ax.grid(True, alpha=0.3) ajoute des lignes de grille discrètes aux graduations ; ax.grid(axis="y") ne dessine que les lignes horizontales, ce qui facilite la lecture de la hauteur des barres.

Les feuilles de style modifient l’aspect par défaut de tous les graphiques créés ensuite : plt.style.use("ggplot"). plt.style.available énumère les styles installés ; les styles proches de ceux de seaborn fournis avec Matplotlib portent par exemple le nom "seaborn-v0_8-whitegrid". Pour appliquer un style à un seul bloc de code, utilise with plt.style.context("ggplot"):.

Les paramètres par défaut individuels se trouvent dans plt.rcParams, par exemple plt.rcParams["font.size"] = 12 ou plt.rcParams["figure.figsize"] = (8, 4). Ils s’appliquent aux figures créées ensuite, et plt.rcdefaults() rétablit les paramètres par défaut de Matplotlib.

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot([1, 2, 3, 4], [62, 48, 55, 40], marker="o", label="North")
ax.set(title="Monthly rainfall, January to April", xlabel="Month", ylabel="Rainfall (mm)", ylim=(0, 70))
ax.set_xticks([1, 2, 3, 4], labels=["Jan", "Feb", "Mar", "Apr"])
ax.legend()
ax.grid(axis="y", alpha=0.3)

.

Dans une figure comportant plusieurs zones de tracé, les fonctions pyplot comme plt.title ou plt.xlabel ne modifient que la zone courante, généralement la dernière créée : un titre peut donc apparaître sur le mauvais panneau. Pour éviter cela, appelle les méthodes de la zone de tracé voulue, par exemple axes[0].set_title(...).

Construis le tableau large des précipitations avec une colonne par station :

import pandas as pd
wide = pd.DataFrame({
    "North": [62, 48, 55, 40],
    "Coast": [110, 95, 80, 60],
    "Valley": [20, 15, 30, 45]
}, index=pd.Index(["Jan", "Feb", "Mar", "Apr"], name="month"))

Chaque objet Series et DataFrame de pandas possède une méthode .plot qui dessine avec Matplotlib et renvoie la zone de tracé Matplotlib utilisée. df.plot(kind="bar") et df.plot.bar() sont deux formes du même appel. Les types sont "line" (par défaut), "bar", "barh", "hist", "box", "kde" ou "density", "area", "pie", "scatter" et "hexbin".

Par défaut, l’index devient l’axe des abscisses et chaque colonne de nombres devient une courbe, avec une légende construite à partir des noms des colonnes. Un objet Series représente ses valeurs en fonction de son index. Pour choisir les colonnes, passe x="month" et y="rain_mm", ou une liste comme y=["North", "Coast"].

Un tableau wide a pour index Jan, Feb, Mar, Apr et pour colonnes North [62, 48, 55, 40], Coast [110, 95, 80, 60] et Valley [20, 15, 30, 45], toutes exprimées en millimètres de précipitations. ax = wide.plot(marker="o", figsize=(8, 4), title="Monthly rainfall"); ax.set_ylabel("Rainfall (mm)") dessine trois courbes avec leurs libellés dans une zone de tracé, puis définit le libellé de l’axe des ordonnées avec une méthode Matplotlib ordinaire.

Arguments courants de .plot : title, xlabel, ylabel, xlim, ylim, figsize, color, legend=False, rot (rotation des libellés des graduations en degrés), grid=True et logy=True. ax= dessine dans une zone de tracé existante, par exemple l’un des panneaux de plt.subplots(1, 2), au lieu de créer une nouvelle figure.

subplots=True dessine chaque colonne dans sa propre zone de tracé et renvoie un tableau NumPy de zones de tracé au lieu d’une seule ; layout=(2, 2) les dispose dans une grille et sharey=True leur donne une même échelle d’ordonnées. Pour le tableau des trois stations, wide.plot(subplots=True, layout=(1, 3), sharey=True) donne un panneau par station.

Les nuages de points et les graphiques à classes hexagonales n’existent que pour les objets DataFrame et nécessitent à la fois x et y : days.plot.scatter(x="temp_c", y="rentals", c="rain_mm", colormap="viridis") colore les points selon les précipitations. Un objet Series ne propose pas de nuage de points : s.plot.scatter() déclenche donc une erreur. df.plot.hist(bins=5) et df.plot.box() donnent un histogramme et une boîte à moustaches pour chaque colonne de nombres.

s.plot.pie() dessine un secteur par valeur, dont la taille dépend de sa part dans le total. Un diagramme circulaire nécessitant un objet Series composé de parts positives ou nulles d’un même ensemble, une colonne d’effectifs comme s.value_counts() est une entrée typique.

Les diagrammes en barres de pandas traitent l’index comme des catégories et placent les barres aux positions 0, 1, 2, … quelles que soient les valeurs de l’index. Les graphiques en courbes utilisent les valeurs réelles de l’index lorsqu’il s’agit de nombres ou de dates. Une courbe et des barres pandas tracées sur la même zone de tracé ne sont donc alignées que si les abscisses de la courbe correspondent aux positions des barres, comme avec un index par défaut 0, 1, 2, … ; pour des années comme 2020 à 2023, la courbe se trouve très à droite des barres. Utilise les mêmes positions pour les deux lorsque tu les combines.

Avec un DatetimeIndex, .plot() place les dates sur l’axe des abscisses et les libelle automatiquement. Les données quotidiennes sont souvent plus lisibles après rééchantillonnage, par exemple en moyennes mensuelles avec s.resample("MS").mean().plot().

.plot ne trace que les colonnes de nombres. Si des nombres ont été lus comme du texte, par exemple parce qu’une colonne contient « 12 mm », la colonne est ignorée et, s’il ne reste aucune donnée numérique, pandas déclenche TypeError: no numeric data to plot. Convertis d’abord la colonne, par exemple avec pd.to_numeric(...).

Un graphique représente les valeurs présentes dans le tableau : calcule donc d’abord les indicateurs voulus. Exemple : un tableau long rain de 12 lignes, une par station et par mois, comporte les colonnes month, station et rain_mm. rain.groupby("station")["rain_mm"].mean() donne une moyenne par station : Coast 86,25 mm, North 51,25 mm et Valley 27,5 mm. L’ajout de .plot.bar() dessine trois barres.

Tracer les lignes brutes par erreur donne les mesures individuelles au lieu des moyennes demandées : rain.plot.bar(x="station", y="rain_mm") dessine 12 barres avec des noms de stations répétés au lieu de trois moyennes.

Trie avant le tracé pour obtenir des barres classées : means.sort_values(ascending=False).plot.bar() place la moyenne la plus élevée à gauche. Pour un graphique horizontal, means.sort_values().plot.barh() place la plus élevée en haut, car la première valeur est dessinée en bas.

s.value_counts() compte les occurrences de chaque catégorie et présente les effectifs du plus fréquent au moins fréquent. Pour les modes de transport « bus », « voiture », « bus », « vélo », « bus », « voiture », il donne bus 3, voiture 2, vélo 1, prêts pour .plot.bar(). Utilise .sort_index() ou .reindex([...]) lorsque les catégories ont un ordre naturel, comme les jours de la semaine.

Un DataFrame au format large, avec une colonne par série, donne dans pandas une courbe ou une couleur de barre par colonne. Remodèle un tableau long avec rain.pivot(index="month", columns="station", values="rain_mm"). Si une paire de valeurs d’index et de colonne apparaît plusieurs fois, pivot déclenche une erreur ; utilise alors pivot_table(..., aggfunc="mean") ou groupby(["month", "station"])["rain_mm"].mean().unstack().

pivot et pivot_table trient le nouvel index : les mois stockés sous forme de chaînes apparaissent donc par ordre alphabétique, Apr, Feb, Jan, Mar, et un graphique en courbes les parcourt alors dans le mauvais ordre. Rétablis l’ordre réel avec wide.reindex(["Jan", "Feb", "Mar", "Apr"]), ou stocke le mois sous forme de variable catégorielle ordonnée ou de numéro de mois avant le pivotement.

Sur un tableau large, wide.plot.bar() dessine des barres groupées, avec un groupe par étiquette d’index et une couleur par colonne, tandis que wide.plot.bar(stacked=True) empile les colonnes. La transposition wide.T.plot.bar() inverse les rôles : un groupe par station, une couleur par mois.

Pour obtenir les proportions au sein de chaque groupe, normalise un tableau de contingence : pd.crosstab(trips["region"], trips["mode"], normalize="index") divise chaque effectif par le total de sa ligne, de sorte que chaque ligne a pour somme 1. Si la région N compte deux trajets en voiture et un en bus, sa ligne donne voiture 0,67 et bus 0,33 (valeurs arrondies). .plot.bar(stacked=True) dessine alors des barres de même hauteur totale qui montrent la répartition des modes de transport dans chaque région.

seaborn fonctionne mieux avec des données au format long : une ligne par observation et une colonne par variable. wide.reset_index().melt(id_vars="month", var_name="station", value_name="rain_mm") reconvertit le tableau large de 4 × 3 en 12 lignes et trois colonnes, afin que station puisse servir à définir la couleur ou les facettes.

seaborn est une bibliothèque de tracé construite sur Matplotlib qui utilise directement les DataFrame de pandas et calcule elle-même des indicateurs statistiques courants. Par convention, elle est importée avec import seaborn as sns. Un appel typique indique le tableau et ses colonnes : sns.scatterplot(data=days, x="temp_c", y="rentals").

Outre x et y, les colonnes peuvent être associées à d’autres caractéristiques visuelles (correspondances sémantiques) : hue définit la couleur, style le marqueur ou le motif des tirets, et size la taille des marqueurs ou l’épaisseur des lignes. seaborn choisit les couleurs et construit lui-même la légende. Une colonne hue catégorielle reçoit des couleurs distinctes ; une colonne de nombres reçoit un dégradé.

Chaque correspondance nécessite une colonne dans les données au format long. Avec le tableau long des précipitations, sns.lineplot(data=rain, x="month", y="rain_mm", hue="station", marker="o") dessine une courbe colorée par station avec une légende. Si hue désigne une colonne absente du tableau, seaborn déclenche une ValueError indiquant qu’il n’a pas pu interpréter la valeur.

Lorsque x contient des chaînes de caractères, seaborn place les catégories dans l’ordre de leur première apparition dans les données : les mois stockés sous la forme « Jan », « Feb », « Mar » dans cet ordre restent donc dans l’ordre du calendrier. Les fonctions par catégorie, comme barplot, boxplot et countplot, acceptent order=["Mon", "Tue", "Wed"] pour définir l’ordre des catégories, et hue_order définit l’ordre des groupes de couleurs dans toute fonction qui comporte hue. lineplot n’a pas d’argument order : pour y fixer l’ordre des noms de mois, transforme la colonne des abscisses en variable catégorielle ordonnée, par exemple avec pd.Categorical(rain["month"], categories=["Jan", "Feb", "Mar", "Apr"], ordered=True).

Les fonctions au niveau d’une zone de tracé, comme scatterplot, lineplot, histplot, boxplot, barplot et heatmap, dessinent dans une zone de tracé Matplotlib, acceptent ax= pour choisir cette zone et la renvoient. Les fonctions au niveau d’une figure, relplot, displot, catplot et lmplot, créent leur propre figure, peuvent la diviser en panneaux avec col et row, et renvoient un objet FacetGrid de seaborn.

Les fonctions au niveau d’une figure définissent les dimensions par panneau : height est la hauteur de chaque panneau en pouces et aspect son rapport largeur-hauteur, de sorte que chaque panneau mesure height × aspect pouces de large ; les valeurs par défaut sont 5 et 1. Comme ces fonctions créent leur propre figure, elles ne peuvent pas dessiner dans une zone de tracé existante : relplot, displot et catplot émettent un avertissement et ignorent ax=, tandis que lmplot le rejette avec une TypeError. Elles placent la légende à l’extérieur des panneaux.

sns.set_theme() applique l’apparence de seaborn à tous les graphiques créés ensuite, y compris ceux de Matplotlib seul : le style « darkgrid », le contexte « notebook » et la palette par défaut de seaborn. style peut valoir « darkgrid », « whitegrid », « dark », « white » ou « ticks » ; context peut valoir « paper », « notebook », « talk » ou « poster » et ajuste la taille des polices et l’épaisseur des lignes, par exemple d’une police de base de 12 points pour « notebook » à 18 points pour « talk ».

palette choisit les couleurs de hue, par exemple palette="colorblind", "Set2" ou "viridis". Dans seaborn 0.13, passer palette sans hue est une pratique dépréciée ; pour colorer les barres selon la catégorie, définis hue avec la même colonne que x et ajoute legend=False : sns.barplot(data=rain, x="station", y="rain_mm", hue="station", legend=False).

Le résultat peut être complété avec Matplotlib :

ax = sns.scatterplot(...)
ax.set(xlabel="Temperature (°C)", ylabel="Rentals per day", title="Rentals and temperature")

. Pour un résultat au niveau d’une figure, utilise les méthodes de la grille, comme g.set_axis_labels("Temperature (°C)", "Rentals per day"), et g.figure.suptitle("...") pour un titre général.

sns.scatterplot(data=days, x="temp_c", y="rentals", hue="weekday", size="rain_mm") dessine un point par ligne, dont la couleur et la taille sont définies par d’autres colonnes. Associer hue et style à une même colonne donne à chaque groupe une couleur et un marqueur distincts, ce qui reste lisible en niveaux de gris.

sns.lineplot agrège les données par défaut : lorsque plusieurs lignes partagent une même abscisse, la courbe passe par la moyenne de leurs ordonnées et une bande ombrée représente l’intervalle de confiance à 95 % de cette moyenne, calculé par bootstrap. Exemple détaillé : pour x = 1, les ordonnées sont 10, 12 et 14 ; pour x = 2, elles sont 20, 21 et 25. La courbe passe par 12 et 22.

La bande par défaut montre l’incertitude de chaque moyenne, pas l’étendue des données. errorbar="sd" ombre à la place une bande allant d’un écart-type sous la moyenne à un écart-type au-dessus ; errorbar=None supprime la bande, et estimator=None (avec units=) trace chaque série individuelle sans calculer de moyenne. Avec une seule ligne par abscisse, il n’y a pas de moyenne à calculer ni de bande.

sns.regplot(data=days, x="temp_c", y="rentals") dessine un nuage de points avec une droite des moindres carrés et une bande de confiance ombrée à 95 % pour cette droite ; order=2 ajuste à la place une courbe quadratique. sns.lmplot fait la même chose en tant que fonction au niveau d’une figure et peut donc aussi répartir les données selon hue, col ou row.

Une ligne ajustée synthétise les données selon le modèle choisi. Une droite peut être tracée sur des données qui suivent une courbe : examine donc les points autour de la droite avant de t’y fier. Une tendance marquée indique que les variables sont liées dans ces données, sans établir de cause.

sns.pairplot(df) dessine une grille avec un nuage de points pour chaque paire de colonnes de nombres et la distribution de chaque colonne sur la diagonale : des histogrammes par défaut, ou des courbes de densité lorsque hue est défini. Quatre colonnes de nombres donnent une grille de 4 × 4, soit 16 panneaux. corner=True ne garde que le triangle inférieur, et vars=[...] limite les colonnes. La fonction renvoie un PairGrid.

sns.jointplot(data=days, x="temp_c", y="rentals") dessine un nuage de points avec l’histogramme de chaque variable sur les bords ; kind="hex" remplace les points par des classes hexagonales, ce qui est utile pour les grands jeux de données.

sns.relplot(..., kind="scatter") et sns.relplot(..., kind="line") sont les versions au niveau d’une figure de scatterplot et lineplot ; le nuage de points est le type par défaut. Utilise-les lorsque la même relation doit être représentée dans un panneau distinct pour chaque groupe.

sns.regplot(data=days, x="temp_c", y="rentals") montre que les locations passent de 180 à 12 °C à environ 350 les jours les plus chauds, avec une corrélation d’environ 0,92. Le jour à 30 °C compte moins de locations (340) que celui à 27 °C (360), si bien que les points s’aplatissent en haut ; un ajustement quadratique (order=2) peut être comparé à la droite.

Les fonctions par catégorie de seaborn placent chaque catégorie aux positions 0, 1, 2, … sur l’axe des catégories. Même les nombres sont traités comme des étiquettes : les années 2020, 2021 et 2023 sont dessinées à intervalles égaux, sans espace pour 2022. native_scale=True conserve un axe numérique avec les espacements réels.

sns.barplot(data=rain, x="station", y="rain_mm") dessine une barre par station, dont la hauteur est la moyenne des valeurs de ses lignes, avec une barre d’erreur représentant l’intervalle de confiance à 95 % de cette moyenne. Avec le tableau des précipitations, les barres valent Coast 86,25, North 51,25 et Valley 27,5 mm. estimator="median" ou estimator="sum" change l’indicateur ; errorbar="sd" ou errorbar=None modifie ou supprime les barres d’erreur.

sns.countplot(data=trips, x="mode") compte les lignes de chaque catégorie et ne nécessite aucune colonne de nombres ; sns.barplot calcule un indicateur sur une colonne de nombres. Utilise countplot pour répondre à « combien d’éléments », et barplot pour répondre à « combien en moyenne ».

sns.pointplot représente la moyenne de chaque groupe par un point accompagné d’une barre d’erreur et relie par une ligne les points de chaque groupe défini par hue. Il facilite la comparaison des changements entre catégories, par exemple les précipitations moyennes de trois stations pour chacun de quatre mois.

Une barre représentant une moyenne masque la dispersion et le nombre d’observations : une moyenne calculée sur 3 lignes paraît aussi solide qu’une moyenne calculée sur 300. Montrer les données est souvent préférable : sns.stripplot dessine chaque observation sous forme de point avec une légère perturbation aléatoire, et sns.swarmplot dispose les points de façon à éviter leur superposition. Un diagramme en points par catégorie peut être superposé à une boîte à moustaches ou à un diagramme en barres dans la même zone de tracé.

Avec hue, les diagrammes en barres, les boîtes à moustaches et les diagrammes en violon placent par défaut les groupes côte à côte dans chaque catégorie (décalage latéral). Les graphiques de points, les diagrammes en points par catégorie et les diagrammes en essaim dessinent les groupes à la même position, sauf si dodge=True est défini : leurs points peuvent donc se superposer. Définis l’ordre des catégories avec order=[...] et celui des groupes avec hue_order=[...].

L’orientation suit les données : place les catégories sur l’axe des ordonnées et les nombres sur l’axe des abscisses, sns.barplot(data=rain, x="rain_mm", y="station"), pour obtenir des barres horizontales dont les longs libellés restent lisibles. orient="y" (ou "h") indique explicitement cette orientation.

sns.catplot est la fonction au niveau d’une figure pour tous les graphiques par catégorie. Son kind peut valoir « strip » (par défaut), « swarm », « box », « violin », « boxen », « point », « bar » ou « count », et col ou row répartit le graphique en panneaux.

Un histogramme découpe l’étendue d’une variable quantitative en intervalles adjacents appelés classes et dessine au-dessus de chaque classe une barre dont la hauteur est le nombre d’observations qu’elle contient. Il montre la forme d’une distribution : sa tendance centrale, sa dispersion, son éventuelle asymétrie, ainsi que les lacunes ou les valeurs inhabituelles.

counts, edges, patches = ax.hist(data, bins=5) dessine l’histogramme et renvoie l’effectif de chaque classe et les bornes des classes. Avec un entier, les classes ont la même amplitude entre le minimum et le maximum ; la valeur par défaut est de 10 classes. Chaque classe inclut sa borne gauche et exclut sa borne droite, sauf la dernière, qui inclut les deux.

Voici 20 durées de trajet domicile-travail, en minutes : 12, 15, 18, 20, 22, 22, 25, 27, 28, 30, 31, 33, 35, 38, 40, 42, 45, 50, 55, 62. Avec bins=5, les bornes sont 12, 22, 32, 42, 52 et 62, et les effectifs sont 4, 7, 4, 3 et 2. La valeur 22 appartient à la deuxième classe, car les classes excluent leur borne droite, et 62 est compté dans la dernière classe, car celle-ci l’inclut.

Le nombre et la position des classes modifient le graphique. Les mêmes 20 durées avec les bornes [10, 20, 30, 40, 50, 60, 70] donnent les effectifs 3, 6, 5, 3, 2 et 1. Trop peu de classes masquent la forme de la distribution ; trop de classes produisent un graphique en dents de scie avec de nombreuses classes presque vides. Essaie plusieurs réglages et privilégie des bornes rondes que les lecteurs peuvent interpréter, par exemple espacées de 10 minutes.

density=True dans Matplotlib, ou stat="density" dans seaborn, ajuste les barres pour que leur aire totale soit égale à 1 : chaque hauteur vaut effectif ÷ (n × amplitude de la classe). Pour les données de trajet réparties en cinq classes de 10 minutes, la hauteur de la deuxième barre est de 7 ÷ (20 × 10) = 0,035 par minute. Une hauteur de densité n’est pas une probabilité ; hauteur × amplitude de la classe donne la proportion d’observations dans la classe.

sns.histplot(data=commutes, x="minutes") dessine un histogramme avec seaborn ; bins et binwidth déterminent les classes. stat choisit la hauteur : « count » (par défaut), « probability » ou « proportion » (la somme des hauteurs vaut 1), « percent » (la somme des hauteurs vaut 100) et « density » (aire de 1). Pour les cinq classes de durées de trajet, « probability » donne 0,2, 0,35, 0,2, 0,15 et 0,1.

Pour comparer des groupes, sns.histplot(data=commutes, x="minutes", hue="mode") superpose un histogramme par groupe ; multiple="stack" les empile, multiple="dodge" les place côte à côte, et element="step" dessine des contours dont la superposition est plus lisible. Pour comparer équitablement des groupes d’effectifs différents, utilise stat="density", common_norm=False, qui ajuste l’aire de chaque groupe à 1.

Une estimation de densité par noyau est une courbe lisse qui estime la forme de la distribution ; l’aire sous la courbe vaut 1. sns.kdeplot(data=commutes, x="minutes") la dessine, et sns.histplot(..., kde=True) l’ajoute à un histogramme. Une valeur de bw_adjust supérieure à 1 rend la courbe plus lisse ; inférieure à 1, elle la rend plus détaillée.

Une courbe d’estimation de densité par noyau s’étend au-delà des valeurs minimale et maximale : elle peut donc montrer une densité en dessous de 0 minute pour des durées qui ne peuvent pas être négatives. cut=0 arrête la courbe aux bornes des données. Pour de petits échantillons, la courbe peut suggérer une forme que les données ne justifient pas.

Dans pandas, commutes["minutes"].plot.hist(bins=5, edgecolor="white") dessine un histogramme (10 classes par défaut), et df.hist() dessine un histogramme par colonne de nombres dans une grille. Dans seaborn, sns.displot est la version au niveau d’une figure : kind="hist" (par défaut), kind="kde" ou kind="ecdf", une fonction de répartition empirique indiquant pour chaque valeur la proportion d’observations inférieures ou égales à celle-ci.

Une boîte à moustaches synthétise une distribution : la boîte s’étend du premier quartile (Q1) au troisième quartile (Q3), un trait à l’intérieur marque la médiane, les moustaches s’étendent vers les valeurs typiques minimale et maximale, et les points au-delà des moustaches sont dessinés un par un comme valeurs aberrantes possibles. L’écart interquartile IQR = Q3 − Q1 est la longueur de la boîte et couvre la moitié centrale des données.

Par défaut, Matplotlib, pandas et seaborn utilisent whis=1.5 : les bornes de détection des valeurs aberrantes sont Q1 − 1,5 × l’écart interquartile et Q3 + 1,5 × l’écart interquartile. Chaque moustache se termine à la valeur observée la plus extrême située à l’intérieur de sa borne, et non à la borne elle-même. Chaque valeur située au-delà des bornes est dessinée comme un point distinct.

Voici 11 délais de livraison, en minutes : 14, 16, 17, 18, 19, 20, 21, 22, 24, 25, 41. Matplotlib calcule Q1 = 17,5, médiane = 20 et Q3 = 23, donc l’écart interquartile vaut 5,5. Les bornes de détection des valeurs aberrantes sont 17,5 − 8,25 = 9,25 et 23 + 8,25 = 31,25. La moustache inférieure se termine à 14, la moustache supérieure à 25 et 41 est représenté par un point comme valeur aberrante.

Les quartiles dépendent de la méthode utilisée. Les bibliothèques de tracé utilisent l’interpolation linéaire entre les valeurs ordonnées, méthode par défaut de NumPy et pandas, qui donne 17,5 et 23 ci-dessus. La méthode manuelle qui consiste à prendre les médianes des moitiés inférieure et supérieure sans la médiane globale donne Q1 = 17 et Q3 = 24 pour les mêmes données. Les deux méthodes sont valides ; les petits écarts entre un calcul à la main et un graphique viennent de là.

Trace la synthèse avec la bibliothèque que tu utilises : ax.boxplot([north, coast], tick_labels=["North", "Coast"]) dans Matplotlib (l’argument s’appelait labels avant la version 3.9) ; rain.boxplot(column="rain_mm", by="station") dans pandas, qui ajoute aussi le titre général « Boxplot grouped by station » ; sns.boxplot(data=rain, x="station", y="rain_mm") dans seaborn, avec hue pour un second regroupement. whis=(0, 100) étend les moustaches jusqu’au minimum et au maximum, et showfliers=False masque les points correspondant aux valeurs aberrantes.

Des boîtes à moustaches placées côte à côte permettent de comparer les groupes d’un coup d’œil : compare les médianes, les longueurs des boîtes (la dispersion de la moitié centrale) et leur chevauchement. Une médiane proche d’une extrémité de la boîte ou une moustache beaucoup plus longue que l’autre indique une distribution asymétrique.

Une boîte ne montre que cinq nombres et les valeurs aberrantes. Elle ne montre pas le nombre d’observations, et des distributions de formes très différentes peuvent avoir la même boîte : une distribution à deux pics distincts et une autre à un seul pic peuvent avoir les mêmes Q1, médiane et Q3. Superposer les points avec sns.stripplot(data=rain, x="station", y="rain_mm", color="black", alpha=0.5) ou utiliser un diagramme en violon permet de le voir.

sns.violinplot(data=rain, x="station", y="rain_mm") dessine pour chaque groupe une courbe de densité symétrique, avec une petite boîte à moustaches à l’intérieur (inner="box", valeur par défaut) ; inner="quart" marque à la place les quartiles par des traits. Avec un hue à deux modalités, split=True place un groupe de chaque côté du violon. Comme une estimation de densité par noyau, le violon peut s’étendre au-delà des données ; cut=0 l’arrête au minimum et au maximum observés.

Un point repéré par la règle de 1,5 × l’écart interquartile est inhabituel par rapport au reste des données, ce qui justifie d’examiner sa valeur. Vérifie-le : il peut s’agir d’une erreur de saisie ou d’une valeur réelle et importante, comme une livraison retardée par la fermeture d’une route. Supprimer des points simplement parce que le graphique les signale fausse l’analyse.

Une carte de chaleur représente un tableau de nombres sous forme d’une grille de cellules colorées : les lignes et les colonnes correspondent à deux catégories ou variables réparties en classes, et la couleur de chaque cellule représente sa valeur. Elle convient à la recherche de structures dans les tableaux à double entrée, comme les visiteurs par jour et par moment de la journée, ainsi que dans les matrices de corrélation.

sns.heatmap(table) prend un tableau large, utilise son index comme libellés des lignes et ses colonnes comme libellés des colonnes, et ajoute une barre de couleurs en guise de légende. Le tableau provient généralement de pivot_table : visits.pivot_table(index="day", columns="slot", values="visitors", aggfunc="mean").

Un musée compte ses visiteurs par demi-journée. Samedi matin : 120 et 140, samedi après-midi : 200 ; dimanche matin : 90, dimanche après-midi : 160 ; lundi matin : 40, lundi après-midi : 70 et 90. Le tableau croisé dynamique des moyennes donne lundi 40 et 80, samedi 130 et 200, dimanche 90 et 160, pour le matin et l’après-midi. sns.heatmap(pt, annot=True, fmt=".0f", cmap="Blues") représente la cellule la plus fréquentée, le samedi après-midi, par la couleur la plus foncée. Le pivotement trie les jours par ordre alphabétique de leurs libellés (Mon, Sat, Sun) ; pt.reindex(["Sat", "Sun", "Mon"]) permettrait de rétablir l’ordre choisi.

annot=True écrit chaque valeur dans sa cellule, et fmt définit le format numérique. La valeur par défaut ".2g" garde deux chiffres significatifs : 43,25 est donc affiché sous la forme « 43 » et 1 234 sous la forme « 1.2e+03 ». Utilise fmt=".0f" pour les nombres entiers ou fmt=".2f" pour deux décimales ; fmt="d" ne fonctionne qu’avec des données de type entier et déclenche une ValueError pour les nombres à virgule flottante.

Une carte de chaleur des corrélations part de corr = df.corr(numeric_only=True), un tableau carré et symétrique dont les coefficients définis vont de −1 à 1. Les colonnes de nombres non constantes ont 1 sur la diagonale ; les corrélations des colonnes constantes ne sont pas définies. Dans pandas 2 et les versions ultérieures, numeric_only vaut False par défaut : df.corr() déclenche donc une erreur lorsque le tableau contient une colonne de texte. Trace la carte avec sns.heatmap(corr, annot=True, fmt=".2f", cmap="vlag", vmin=-1, vmax=1, center=0).

Voici huit jours avec la température (°C), les locations de vélos, les précipitations (mm) et le vent (km/h). La matrice de corrélation donne 0,92 pour la température et les locations, −0,82 pour les locations et les précipitations, 0,75 pour les précipitations et le vent, et −0,38 pour la température et le vent. Avec la palette « vlag », la paire fortement positive apparaît en rouge foncé, la paire fortement négative en bleu foncé et la faible corrélation entre température et vent dans une teinte pâle proche du blanc central.

Sans vmin et vmax, l’échelle de couleurs s’étend de la plus petite à la plus grande valeur du tableau : une même couleur peut donc représenter des valeurs différentes dans deux cartes de chaleur. Fixe les bornes pour comparer les cartes, et utilise vmin=-1, vmax=1 pour les corrélations. Une palette séquentielle comme « rocket » (valeur par défaut de seaborn), « viridis » ou « Blues » convient aux valeurs allant du bas au haut de l’échelle ; une palette divergente comme « vlag », « coolwarm » ou « RdBu_r », avec center placé à une valeur centrale pertinente, convient aux valeurs situées de part et d’autre d’une référence comme 0. Lorsque center est défini sans cmap, seaborn utilise la palette divergente « icefire ».

Options utiles : linewidths=0.5 dessine des traits fins entre les cellules, square=True rend les cellules carrées, cbar_kws={"label": "Visitors"} ajoute un libellé à la barre de couleurs, et les valeurs manquantes (NaN) restent vides. mask=np.triu(np.ones_like(corr, dtype=bool)) masque le triangle supérieur et la diagonale d’une matrice de corrélation, qui répètent le triangle inférieur.

Dans Matplotlib, im = ax.imshow(values, cmap="viridis"); fig.colorbar(im, ax=ax) dessine une carte de chaleur d’un tableau à 2 dimensions, avec la ligne 0 en haut ; « viridis » est la palette par défaut de Matplotlib. imshow libelle les axes avec les numéros de lignes et de colonnes : définis donc toi-même les noms avec ax.set_xticks(range(len(cols)), labels=cols). ax.pcolormesh est une solution possible lorsque les cellules ont des tailles différentes.

Un coefficient de corrélation ne mesure que la force d’une liaison linéaire. Une corrélation proche de 0 n’exclut pas une forte relation courbe, et une seule valeur aberrante peut fortement augmenter ou diminuer un coefficient. Examine les nuages de points correspondants, par exemple avec une matrice de nuages de points, avant d’interpréter une carte de chaleur des corrélations.

Les petits multiples sont un ensemble de graphiques du même type, chacun correspondant à un sous-ensemble des données, tracés avec les mêmes échelles et placés côte à côte pour permettre la comparaison. Dans Matplotlib, ils sont construits sous forme d’une grille de zones de tracé dans une même figure.

fig, axes = plt.subplots(2, 3, figsize=(12, 6)) renvoie une figure et un tableau NumPy de 2 × 3 zones de tracé. axes[0, 0] est le panneau en haut à gauche et axes[1, 2] celui en bas à droite. Avec une seule ligne ou une seule colonne, le tableau est unidimensionnel : plt.subplots(1, 3) donne donc axes[0], axes[1] et axes[2]. axes.flat parcourt tous les panneaux ligne par ligne.

Le tableau lui-même ne peut pas dessiner : axes.plot(...) déclenche AttributeError: 'numpy.ndarray' object has no attribute 'plot'. Sélectionne d’abord un panneau par son indice, comme dans axes[0, 1].plot(...).

sharex=True et sharey=True donnent à tous les panneaux les mêmes bornes en abscisse ou en ordonnée : des hauteurs égales représentent donc des valeurs égales dans tous les panneaux et seuls les panneaux extérieurs affichent les libellés des graduations. Sans axes partagés, chaque panneau adapte son échelle à ses propres données et une petite étendue peut paraître aussi grande qu’une grande.

fig, axes = plt.subplots(2, 2, sharey=True, layout="constrained"), puis for ax, (name, grp) in zip(axes.flat, rain.groupby("station")): ax.plot(grp["month_num"], grp["rain_mm"], marker="o"); ax.set_title(name). Les trois stations occupent trois des quatre panneaux ; axes[1, 1].axis("off") masque le quatrième, qui est vide.

Les libellés de panneaux voisins peuvent se chevaucher. layout="constrained" dans plt.subplots ou plt.figure ajuste automatiquement l’espacement ; fig.tight_layout(), appelé après le tracé, est l’ancienne solution. fig.suptitle("Monthly rainfall by station") ajoute un titre à toute la figure, et fig.supxlabel(...) et fig.supylabel(...) ajoutent des libellés d’axes partagés.

Panneaux de tailles différentes : plt.subplots(1, 2, gridspec_kw={"width_ratios": [2, 1]}) rend le panneau de gauche deux fois plus large que celui de droite. fig, axd = plt.subplot_mosaic([["top", "top"], ["left", "right"]]) renvoie un dictionnaire de zones de tracé, ici un panneau large axd["top"] au-dessus de deux panneaux plus petits.

Les graphiques pandas et les fonctions seaborn au niveau d’une zone de tracé peuvent remplir des panneaux choisis avec ax= : wide["North"].plot(ax=axes[0, 0]) ou sns.histplot(data=commutes, x="minutes", ax=axes[0, 1]). C’est ainsi que l’on combine des graphiques des trois bibliothèques dans une même figure.

La répartition en facettes trace le même graphique pour chaque modalité d’une variable qualitative, chacune dans son propre panneau, avec des axes partagés. Les fonctions seaborn au niveau d’une figure le font avec col= (panneaux côte à côte), row= (panneaux empilés) et col_wrap= (passage à une nouvelle ligne après le nombre de colonnes indiqué).

sns.relplot(data=rain, x="month_num", y="rain_mm", col="station", col_wrap=2, kind="line", height=3, aspect=1.5) dessine trois panneaux, deux sur la première ligne et un sur la seconde. Chaque panneau mesure 3 pouces de haut et 3 × 1,5 = 4,5 pouces de large ; la figure mesure donc environ 9 × 6 pouces.

row et col combinés créent une grille avec un panneau par combinaison de modalités : deux saisons en lignes et trois stations en colonnes donnent 2 × 3 = 6 panneaux. col_wrap ne peut pas être combiné avec row.

Les mêmes arguments fonctionnent pour tous les types de graphiques : sns.displot(data=commutes, x="minutes", col="mode") donne un histogramme par mode de transport, et sns.catplot(data=rain, x="station", y="rain_mm", col="season", kind="box") donne des boîtes à moustaches par saison.

Par défaut, les panneaux partagent leurs axes des abscisses et des ordonnées, ce qui permet de comparer les hauteurs entre panneaux. Laisser chaque panneau adapter son échelle à ses propres données montre les détails des petits groupes, mais peut rendre trompeuse une comparaison visuelle entre panneaux. Avec relplot et displot, passe facet_kws={"sharey": False} ; catplot accepte directement sharey=False, et le passer aussi dans facet_kws déclenche une TypeError.

sns.FacetGrid construit directement la grille puis dessine dans chaque panneau : g = sns.FacetGrid(commutes, col="mode", height=3); g.map_dataframe(sns.histplot, x="minutes"); g.add_legend(). g.map(plt.scatter, "temp_c", "rentals") transmet les colonnes nommées comme arguments positionnels à une fonction de tracé.

Personnalise la grille avec ses méthodes : g.set_titles("{col_name}") définit les titres des panneaux à partir des noms des modalités, g.set_axis_labels("Month", "Rainfall (mm)") libelle tous les axes, et g.set(ylim=(0, 120)) applique un réglage de zone de tracé à chaque panneau. g.axes_dict["Coast"] ou g.axes.flat permet d’accéder aux zones de tracé individuelles, et g.figure.suptitle("Rainfall by station", y=1.02) ajoute un titre général au-dessus des panneaux.

hue et col répartissent tous deux les données selon une variable. hue superpose les groupes dans une même zone de tracé, ce qui facilite la comparaison directe de quelques groupes ; col les sépare, ce qui reste lisible lorsque les lignes ou les points se chevaucheraient ou lorsque les groupes sont nombreux. Les deux peuvent être utilisés simultanément, par exemple col="station", hue="season".

Les fonctions au niveau d’une figure ne dessinent pas dans une zone de tracé existante (relplot, displot et catplot ignorent ax= en émettant un avertissement, et lmplot le rejette) et n’acceptent pas figsize de Matplotlib : le passer déclenche une erreur. Définis les dimensions de la grille avec height et aspect. Pour placer un graphique à facettes à côté d’autres graphiques dans une figure Matplotlib, construis les panneaux avec plt.subplots et des fonctions au niveau d’une zone de tracé.

ax.text(x, y, "text") écrit du texte à un point donné en coordonnées des données, dans les mêmes unités que les valeurs représentées. ha (« left », « center », « right ») et va (« top », « center », « bottom ») alignent le texte sur ce point ; fontsize et color définissent son style.

Avec transform=ax.transAxes, les positions sont des fractions de la zone de tracé : (0 ; 0) est le coin inférieur gauche et (1 ; 1) le coin supérieur droit. ax.text(0.02, 0.95, "n = 20", transform=ax.transAxes, va="top") garde une note dans le coin supérieur gauche quelles que soient les données et les bornes. Un texte placé en coordonnées des données se déplace lorsque les bornes changent et peut se retrouver à l’extérieur de la zone de tracé.

ax.annotate("Wettest month", xy=(1, 110), xytext=(2, 115), arrowprops=dict(arrowstyle="->")) écrit le texte à la position xytext et dessine une flèche vers le point xy ; les deux sont par défaut en coordonnées des données. textcoords="offset points" fait de xytext un décalage par rapport à xy, en points, par exemple xytext=(10, 10) pour 10 points vers la droite et vers le haut.

Les lignes de référence traversent toute la zone de tracé : ax.axhline(50, color="gray", linestyle="--", label="Target") dessine une ligne horizontale à y = 50, et ax.axvline(...) une ligne verticale. ax.axvspan(6, 8, alpha=0.2) ombre la plage de x = 6 à x = 8, par exemple une période de vacances. ax.hlines(y, xmin, xmax) dessine des lignes horizontales sur une plage limitée.

Sur l’histogramme des 20 durées de trajet domicile-travail, la moyenne est de 650 ÷ 20 = 32,5 minutes et la médiane de 30,5 minutes. ax.axvline(32.5, color="black", linestyle="--"); ax.text(33.5, 6.5, "mean 32.5 min") marque la moyenne, située à droite de la médiane parce que quelques longs trajets la tirent vers le haut.

Valeurs des barres : ax.bar_label(bars, fmt="%.0f") ajoute des étiquettes aux barres renvoyées par ax.bar. Pour les barres dessinées par pandas ou seaborn, les barres sont stockées dans ax.containers : ax.bar_label(ax.containers[0]) ajoute donc les étiquettes de la première série. padding=3 éloigne les étiquettes de 3 points des extrémités des barres.

Les formes proviennent de matplotlib.patches : ax.add_patch(Rectangle((x, y), width, height, fill=False, edgecolor="red")) trace le contour d’une région en coordonnées des données, et Circle et Polygon fonctionnent de la même façon.

Le texte peut être calculé à partir des données avec des f-strings, afin que les libellés restent corrects lorsque les données changent : ax.text(..., f"mean {commutes['minutes'].mean():.1f} min"). Les annotations sont dessinées au-dessus des données ; place-les dans des zones vides et limite leur nombre pour qu’elles mettent en évidence les éléments importants.

fig.savefig("rainfall.png") enregistre la figure ; l’extension du fichier détermine le format : PNG et JPEG sont des images matricielles constituées de pixels, tandis que SVG et PDF sont des images vectorielles constituées de formes. format="pdf" définit explicitement le format.

Les images matricielles ont un nombre fixe de pixels et deviennent floues lorsqu’on les agrandit ; les fichiers vectoriels restent nets à toute taille et conviennent aux rapports, à l’impression et aux documents. PNG est un bon format matriciel pour les graphiques sur le Web et dans les diapositives. La compression JPEG est avec perte et rend flous les traits fins et le texte : ce format convient donc mal aux graphiques.

Dimensions en pixels = dimensions de la figure en pouces × dpi (points par pouce). fig, ax = plt.subplots(figsize=(8, 5)), enregistré avec dpi=150, donne 8 × 150 sur 5 × 150 = 1 200 × 750 pixels. Sans dpi, savefig utilise la résolution propre de la figure, soit 100 dpi par défaut : la même figure mesure alors 800 × 500 pixels. Pour les formats vectoriels, le dpi ne touche que les parties matricielles intégrées.

La taille du texte et l’épaisseur des lignes sont définies en points (1 point = 1/72 pouce), par rapport aux dimensions de la figure en pouces. Augmenter le dpi ajoute des pixels sans modifier la taille apparente du texte par rapport au graphique ; agrandir figsize rend au contraire le texte relativement plus petit. Choisis figsize selon la taille d’affichage finale et dpi selon la netteté voulue.

bbox_inches="tight" réduit les marges vides et inclut les éléments qui dépassent de la figure, comme une légende placée hors de la zone de tracé ; l’image enregistrée est alors un peu plus petite ou plus grande que les dimensions de la figure × dpi. pad_inches=0.1 définit la marge conservée autour.

transparent=True enregistre sans arrière-plan, ce qui convient aux diapositives à fond coloré ; facecolor="white" impose un fond blanc, ce qui est utile lorsqu’un thème sombre de notebook risquerait autrement de se retrouver dans le fichier.

plt.savefig enregistre la figure courante : appelle-le donc avant un plt.show() bloquant. Une fois la fenêtre fermée, pyplot ne suit plus cette figure et un appel ultérieur à plt.savefig(...) enregistre une nouvelle figure vide. Dans un notebook Jupyter, pyplot libère aussi la figure à la fin de la cellule : plt.savefig dans une cellule ultérieure enregistre donc une image vide. Conserver la figure dans une variable évite ces deux problèmes : fig.savefig(...) fonctionne encore après plt.show() ou dans une cellule ultérieure du notebook.

Les résultats seaborn s’enregistrent de la même façon : un graphique au niveau d’une zone de tracé s’enregistre par sa figure, avec ax.figure.savefig("box.png", dpi=200), et une grille au niveau d’une figure avec g.savefig("facets.png", dpi=200), qui utilise par défaut des boîtes englobantes ajustées.

for name, grp in rain.groupby("station"):
    grp = grp.sort_values("month_num")
    fig, ax = plt.subplots(figsize=(6, 4))
    ax.plot(grp["month_num"], grp["rain_mm"], marker="o")
    ax.set(title=name, xlabel="Month", ylabel="Rainfall (mm)")
    fig.savefig(f"rain_{name}.png", dpi=150, bbox_inches="tight")
    plt.close(fig)

. Fermer chaque figure limite l’utilisation de la mémoire et évite l’avertissement concernant plus de 20 figures ouvertes.