Tutoriel Plotly Express en Python : créez des visualisations superbes

Plotly ne se limite pas à créer de belles visualisations : c’est un moyen de libérer tout le potentiel de vos données et de révéler des insights qui seraient autrement restés invisibles. C’est le pont entre le langage des chiffres et celui des histoires, qui permet aux personnes comme aux organisations de prendre des décisions éclairées et d’avoir un véritable impact.

C’est ainsi que ChatGPT décrit Plotly. Clairement, Plotly fait partie des meilleures bibliothèques de visualisation de données.

Elle permet de créer des graphiques très interactifs et visuellement attrayants comme celui ci‑dessous :

Aujourd’hui, vous allez apprendre les fondamentaux pour réaliser des visuels remarquables avec Plotly.

Notions de base de Plotly Express

Comme pour tout tutoriel, commençons par installer la bibliothèque via pip (ou conda si vous préférez).

$ pip install --upgrade plotly
$ conda install -c conda-forge plotly

Plotly est régulièrement mis à jour, donc assurez-vous d’inclure l’option --upgrade si vous avez déjà la bibliothèque installée.

Ce tutoriel se concentre sur l’API Express de Plotly, introduite en 2019, qui offre de nombreux avantages par rapport aux anciennes manières d’interagir avec le cœur de la bibliothèque Plotly :

• Syntaxe simple (presque naturelle)
• Large éventail de visualisations (et des outils pour créer les vôtres)
• Mise à l’échelle automatique des axes et des couleurs
• Intégration avec pandas (vous pouvez utiliser Plotly comme moteur de tracé pour la fonction .plot de pandas)

Voici l’anatomie d’un graphique de base avec Plotly Express :

import plotly.express as px

fig = px.plotting_function(
    dataframe,
    x='column-for-xaxis',
    y='column-for-yaxis',
    title='Title For the Plot',
    width=width_in_pixels,
    height=height_in_pixels
)

fig.show()

Chaque type de graphique dispose de sa propre fonction, comme histogram ou scatter, sous le module express importé en px. Le premier argument de toute fonction de tracé est le DataFrame, puis les noms de colonnes à représenter sur les axes X et Y.

Bonne pratique : donnez à vos graphiques un title informatif pour que les lecteurs comprennent immédiatement l’objet du visuel.

Une fois exécutée, la fonction de tracé renvoie un objet Figure sur lequel vous appelez la méthode show pour afficher le graphique dans votre notebook.

Pour commencer à créer des graphiques, il nous faut un jeu de données. Pour ce tutoriel, nous utilisons le jeu de données Diamonds. Il contient un bon mélange de variables numériques et catégorielles : parfait pour notre objectif.

import pandas as pd

diamonds = pd.read_csv("data/diamonds.csv")

diamonds.head()

Le jeu de données contient plus de 53 000 diamants et 10 caractéristiques physiques. Vous pouvez explorer les statistiques de base ci‑dessous.

diamonds.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 53940 entries, 0 to 53939
Data columns (total 10 columns):
#   Column   Non-Null Count  Dtype 
---  ------   --------------  ----- 
0   carat    53940 non-null  float64
1   cut      53940 non-null  object
2   color    53940 non-null  object
3   clarity  53940 non-null  object
4   depth    53940 non-null  float64
5   table    53940 non-null  float64
6   price    53940 non-null  int64 
7   x        53940 non-null  float64
8   y        53940 non-null  float64
9   z        53940 non-null  float64
dtypes: float64(6), int64(1), object(3)
memory usage: 4.1+ MB

diamonds.describe()

L’une des premières étapes d’une analyse exploratoire des données (EDA) consiste à examiner les distributions individuelles.

Plotly propose de nombreux graphiques pour cela : histogrammes, boîtes à moustaches, violons, diagrammes en barres, etc. Voyons quelques exemples.

Histogrammes avec Plotly Express

L’histogramme est probablement le premier visuel que l’on apprend.

Il ordonne les valeurs d’une distribution et les regroupe en classes (bins). Des barres représentent ensuite combien de valeurs tombent dans chaque classe :

import plotly.express as px
​
fig = px.histogram(
  diamonds,
  x="price",
  title="Histogram of diamond prices",
  width=600,
  height=400,
)
​
fig.show()

En survolant une barre, vous voyez l’intervalle de la classe correspondante. Plotly détermine automatiquement le nombre de classes, mais si vous souhaitez le définir vous‑même, utilisez le paramètre nbins.

Il est toutefois difficile de trouver le nombre idéal de classes pour chaque distribution. Une règle courante consiste à fixer ce nombre à la racine carrée de la longueur de la distribution :

# Déterminer un nombre de classes adéquat
nbins = int(len(diamonds) ** (1 / 2))
​
fig = px.histogram(
  diamonds,
  x="price",
  title="Histogram of diamond prices",
  nbins=nbins,
  width=600,
  height=400,
)
​
fig.show()

Diagrammes en barres avec Plotly Express

Les histogrammes analysent des variables quantitatives. Pour les données catégorielles, on se tourne vers les diagrammes en barres. Par exemple, en passant la colonne catégorielle cut à la fonction histogram, on obtient un type de barres appelé countplot. Oui, vous l’avez deviné : il compte le nombre d’observations par catégorie.

fig = px.histogram(diamonds, x="cut")
​
fig.show()

Mais attendez, nous n’avons ajouté aucun libellé ! Corrigeons cela avec la fonction update_layout, qui permet de modifier de nombreux aspects d’une figure après sa création.

fig.update_layout(
  title="The number of diamonds in each diamond cut category",
  xaxis_title="",
  yaxis_title="Count",
)

Vous savez déjà à quoi sert title. Les paramètres xaxis_title et yaxis_title remplacent les étiquettes d’axes générées automatiquement par Plotly (qui sont simplement les noms de colonnes).

Voyons maintenant le prix moyen pour chaque catégorie de taille de diamant. Commençons par groupby dans pandas :

mean_prices = (
    diamonds.groupby("cut")["price"].mean().reset_index()
)

mean_prices

Chaîner reset_index à la fin d’un groupby renvoie un DataFrame, et Plotly adore les DataFrames. Passons‑le donc à la fonction bar :

fig = px.bar(mean_prices, x="cut", y="price")
​
fig.update_layout(
  title="Average diamond prices for each cut category",
  xaxis_title="",
  yaxis_title="Mean price ($)",
)
​
fig.show()

bar prend une variable catégorielle et une variable numérique, et crée une barre pour chaque ligne du DataFrame fourni. Le résultat offre une comparaison lisible des prix par type de diamant.

Boîtes à moustaches avec Plotly Express

Un autre graphique courant pour analyser des distributions est la boîte à moustaches, créée avec box dans Plotly Express :

fig = px.box(diamonds, x="clarity", y="carat")
​
fig.update_layout(
  title="Distribution of diamond carats for each clarity category",
  xaxis_title="Clarity",
  yaxis_title="Carat",
)
​
fig.show()

Au lieu d’afficher de simples barres qui ne montrent que la moyenne des carats, la boîte à moustaches présente plusieurs statistiques :

On y voit :

• minimum/maximum
• médiane
• 25e centile
• 75e centile
• et valeurs aberrantes

pour chaque catégorie de pureté (clarity) de diamant.

Graphiques en violon avec Plotly Express

Un autre graphique agréable pour explorer des distributions est le violon. Les violons sont, en substance, des boîtes à moustaches enrichies :

fig = px.violin(diamonds, x="cut", y="price")
​
fig.show()

Au lieu d’une boîte, on affiche une courbe lissée représentant la densité d’une variable. Pour superposer une boîte à moustaches, définissez l’attribut box à True :

fig = px.violin(diamonds, x="cut", y="price", box=True)
​
fig.show()

Contrairement aux boîtes à moustaches qui se limitent aux statistiques de synthèse, les violons montrent aussi la forme de la distribution.

Visualiser les relations entre variables avec Plotly Express

En traçant des variables liées entre elles, vous ferez émerger de nouveaux motifs et insights. Par exemple, si l’on suppose que le carat (le poids) est le principal facteur expliquant le prix du diamant, explorons cette relation.

Nuages de points avec Plotly Express

Utilisons un nuage de points (px.scatter) qui représente chaque diamant du jeu de données par un point. La position des points est déterminée par leur prix et leur carat :

fig = px.scatter(diamonds, x="price", y="carat")
​
fig.update_layout(
  title="Price vs. Carat",
  xaxis_title="Price ($)",
  yaxis_title="Carat",
)
​
fig.show()

Nous sommes confrontés à un problème de sur‑tracé (overplotting), qui survient lorsqu’il y a trop de données sur un seul graphique. Au lieu de révéler les tendances, elles sont masquées.

Nous pouvons corriger cela en ne traçant qu’environ 10 % du jeu de données, ce qui suffit à faire apparaître les motifs pertinents :

fig = px.scatter(
  diamonds.sample(5000), x="price", y="carat"
)
​
fig.update_layout(
  title="Price vs. Carat",
  xaxis_title="Price ($)",
  yaxis_title="Carat",
)
​
fig.show()

Dans l’appel à scatter, nous passons seulement 5 000 lignes (.sample(5000)), ce qui met en évidence une légère tendance haussière entre prix et carat.

Cartes thermiques (heatmaps) avec Plotly Express

Les heatmaps sont excellentes pour visualiser des jeux de données complexes, par exemple une grande matrice où des colonnes de chiffres masquent les motifs.

Une heatmap attribue des couleurs selon l’intensité de chaque cellule de la matrice. Un cas d’usage classique est l’inspection de la matrice de corrélation d’un jeu de données.

La corrélation mesure la relation linéaire entre variables numériques. Chaque cellule de la matrice représente donc la corrélation d’un couple de variables.

Vous pouvez calculer la matrice de corrélation avec la méthode corr de pandas, qui renvoie un DataFrame. En la passant à la fonction imshow d’Express, vous obtenez une heatmap :

import plotly.express as px
​
# Create heatmap using Plotly Express
fig = px.imshow(
  diamonds.corr(),
  color_continuous_scale="Inferno_r",
)
​
# Show plot
fig.show()

La corrélation varie de -1 à 1. Des valeurs proches des extrêmes indiquent une relation linéaire fortement positive ou négative.

Ici, nous choisissons la palette « Inferno » inversée pour le paramètre color_continuous_scale. Vous pouvez en sélectionner d’autres sur la page des échelles de couleurs de la documentation Plotly.

Personnaliser ses graphiques avec Plotly Express

L’un des grands atouts de l’API Plotly Express est la facilité de personnalisation.

La fonction update_layout propose de nombreux paramètres pour modifier quasiment tous les aspects de vos graphiques.

Selon l’endroit où vos visuels seront diffusés, c’est à vous de les rendre impeccables pour tout public, lieu ou support.

Parmi les premiers choix : le thème. Les thèmes Plotly sont des configurations par défaut qui pilotent presque tous les composants d’un graphique.

Vous pouvez le changer via le paramètre template de n’importe quelle fonction de tracé :

sample = diamonds.sample(3000)
​
fig = px.scatter(
  sample, x="price", y="carat", template="ggplot2"
)
​
fig.show()

Parmi les populaires : ggplot2, seaborn, plotly_dark et presentation. Vous pouvez lister l’ensemble via plotly.io.templates.

Couleurs

Jusqu’ici, nos nuages de points étaient bi‑dimensionnels. Mais on peut y ajouter une information supplémentaire avec la couleur.

Par exemple, colorer chaque point selon la catégorie du diamant. Pour cela, passez simplement cut au paramètre color :

sample = diamonds.sample(3000)
​
fig = px.scatter(sample, x="price", y="carat", color="cut")
​
fig.show()

Le paramètre color force également l’affichage d’une légende indiquant la couleur de chaque catégorie.

Taille des marqueurs

Autre approche : représenter une variable numérique par la taille des points.

En définissant size sur carat, on obtient des points de tailles différentes selon le carat :

fig = px.scatter(sample, x="price", y="x", size="carat")
​
fig.show()

Et si l’on combinait couleur et taille ? Allons‑y !

fig = px.scatter(
  sample, x="price", y="x", size="carat", color="cut"
)
​
fig.show()

Mais ce graphique devient moins lisible : il contient trop d’informations pour l’œil. En pratique, évitez d’empiler plus de trois variables sur un même visuel.

Conclusion

Bravo d’être allé jusqu’au bout ! Vous avez désormais de quoi continuer à apprendre Plotly en autonomie avec nos autres ressources :

• Introduction to data visualization with Plotly in Python course
• Data Visualization with Plotly in R tutorial
• Creating histograms in Plotly tutorial

Vous pouvez également découvrir l’API Graph Objects de Plotly, qui offre davantage d’options de personnalisation, un contrôle poussé de l’interactivité et des animations, ainsi que la prise en charge de types de visualisations avancés.