Construire un nuage de points (scatter plot) avec Python

Les nuages de points, ou scatter plots, sont des visualisations très utiles pour représenter deux (voire plusieurs) variables numériques et observer leur éventuelle relation. Dans cet article, nous allons voir :

1. Comment générer ou importer des données.
2. Comment tracer un nuage de points avec la bibliothèque Matplotlib (et éventuellement Seaborn).
3. Quelques astuces pour personnaliser et enrichir cette visualisation.

1. Installation et import des packages

Si vous ne l’avez pas déjà fait, vous devez installer les bibliothèques Python nécessaires : principalement matplotlib et numpy (et éventuellement seaborn pour des visualisations plus esthétiques).

pip install matplotlib numpy seaborn

Ensuite, dans votre script ou votre notebook, importez les librairies :

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

2. Générer ou importer des données

2.1 Générer un jeu de données aléatoires

Pour illustrer la création d’un nuage de points, nous allons commencer par générer un petit jeu de données aléatoires :

# Définir le nombre d'observations
n = 100

# Générer des données pour l'axe X
x = np.random.rand(n) * 10  # des valeurs entre 0 et 10

# Générer des données pour l'axe Y
# Imaginons qu'on a une relation linéaire (ex: y = 2x + un bruit aléatoire)
y = 2 * x + (np.random.randn(n) * 2)  # bruit de variance 2

# Pour la démonstration, on crée également une variable "catégorie"
categories = np.random.choice(['A', 'B', 'C'], size=n)

2.2 Importer des données depuis un fichier CSV

Dans la vraie vie, vous voudrez souvent importer vos données depuis un fichier CSV ou une base de données. Voici un exemple rapide :

import pandas as pd

df = pd.read_csv("https://www.stat4decision.com/airbnb.csv")
x_1 = df["longitude"]
y_1 = df["latitude"]

Pour ce tutoriel, nous nous illustrerons notre nuage de points avec ces deux jeux de données.

3. Créer un nuage de points avec Matplotlib

Le code de base pour générer un nuage de points avec Matplotlib est très simple, grâce à la fonction plt.scatter().

Décryptage du code

• fig, ax = plt.subplots(figsize=(8, 6)) : on crée une figure (taille 8×6 pouces) et un objet axe.
• ax.scatter(x, y, ...) : la méthode scatter prend en argument les listes ou tableaux de données que l’on souhaite représenter sur l’axe X et l’axe Y.
• color='blue' : définit la couleur des points.
• alpha=0.7 : ajuste la transparence (entre 0 et 1), ce qui peut aider à mieux visualiser les zones de chevauchement.
• s=1 : définit la taille des points (en pixels)
• ax.set_xlabel(...) et ax.set_ylabel(...) : étiquettent les axes pour plus de clarté.
• ax.set_axis_off() : retire tous les axes
• ax.set_title(...) : ajoute un titre au graphique.
• plt.savefig("nuage2.png") : sauvegarde la figure dans une image.
• plt.show() : affiche la figure dans la fenêtre ou le notebook.

4. Améliorer la visualisation

4.1 Représenter la taille ou la couleur en fonction d’une variable

Il est souvent utile de représenter une troisième variable par la taille ou la couleur des points. Dans notre exemple, nous pouvons calculer une variable z qui dépend de x et y :

# Exemple : créer une variable z (taille du point)
z = (x + y) * 5  # juste à titre d'illustration

# Créer le scatter plot en intégrant la taille et la couleur
fig, ax = plt.subplots(figsize=(8, 6))
scatter = ax.scatter(x, y, s=z, c=z, cmap='viridis', alpha=0.7)

# Ajouter la barre de couleurs
plt.colorbar(scatter, ax=ax, label='Valeur de Z')

ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_title("Nuage de points avec taille/couleur selon une 3e variable")

plt.savefig("nuage3.png")
plt.show()

Ici, nous ajoutons :

• s=z : la taille des points dépend de la valeur de z.
• c=z, cmap='viridis' : la couleur des points dépend également de z, et nous utilisons la palette de couleurs « viridis ».
• plt.colorbar(...) : on ajoute une légende des couleurs à côté du graphique.

4.2 Différencier des catégories

Si vous souhaitez colorer les points en fonction de catégories (comme notre variable categories), vous pouvez soit faire plusieurs appels à scatter (un pour chaque catégorie), soit utiliser seaborn, qui facilite ce travail.

Option 1 : Boucle sur chaque catégorie avec Matplotlib

categories_unique = np.unique(categories)

fig, ax = plt.subplots(figsize=(8, 6))

for cat in categories_unique:
    indices = (categories == cat)
    ax.scatter(x[indices], y[indices], label=f"Catégorie {cat}", alpha=0.7)

ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_title("Nuage de points avec des catégories")
ax.legend()

plt.savefig("nuage4.png")
plt.show()

Ici, on boucle sur les catégories distinctes, et on appelle scatter pour tracer chaque groupe avec une légende associée (ax.legend()).

Option 2 : Utiliser Seaborn

Seaborn fournit un scatterplot qui peut directement gérer une variable de type catégorie ou numérique pour la couleur.

plt.figure(figsize=(8, 6))
sns.scatterplot(data=df, 
                x="longitude", 
                y="latitude", 
                hue='host_is_superhost',
                alpha=1, s=4)
plt.axis("off")
plt.title("""Logements airbnb à Paris et niveau des host""")

plt.savefig("nuage5.png")
plt.show()

5. Ajouter des fonctionnalités supplémentaires

5.1 Ajouter une ligne de régression

Toujours avec Seaborn, vous pouvez ajouter automatiquement une ligne de régression pour visualiser la tendance :

plt.figure(figsize=(8, 6))
sns.regplot(x=x, y=y, ci=None, scatter_kws={"alpha": 0.7})
plt.title("Nuage de points avec ligne de régression")
plt.savefig("nuage6.png")
plt.show()

Remarque : ci=None supprime la représentation de l’intervalle de confiance. Vous pouvez l’enlever ou régler sa valeur.

5.2 Afficher un texte / Label pour chaque point

Dans certains cas, vous souhaiterez étiqueter chaque point. La manière la plus simple, en pur Matplotlib, est d’utiliser la fonction ax.text() ou plt.annotate() :

fig, ax = plt.subplots(figsize=(8, 6))
ax.scatter(x, y, alpha=0.7)

# un label au-dessus de chaque point
for i in range(len(x)):
    ax.annotate(f"{i}", (x[i], y[i]+0.2))  

ax.set_title("Nuage de points avec étiquettes")
plt.savefig("nuage7.png")
plt.show()

Veillez cependant à ne pas surcharger le visuel si vous avez beaucoup de points !

---

Conclusion

Nous avons vu dans ce tutoriel comment créer un nuage de points en Python :

• Matplotlib pour la construction de base,
• Seaborn pour simplifier l’ajout de catégories, la mise en forme et l’ajout d’une régression linéaire,
• Des astuces pour ajouter de la couleur, la taille des points, des étiquettes, etc.

Ces techniques constituent la base pour visualiser et analyser la relation entre deux (ou plusieurs) variables. N’hésitez pas à explorer davantage les fonctionnalités de Matplotlib et Seaborn pour personnaliser vos graphiques, ou à combiner ces librairies avec d’autres (Plotly, bokeh) afin de créer des nuages de points interactifs !

Bonnes visualisations !