Skip to content

Matplotlib Nuage de Points : Guide Complet de plt.scatter()

Soren Atelier
Name
Soren Atelier

Updated on

Les nuages de points sont la visualisation incontournable pour explorer les relations entre deux variables numériques. Mais créer des nuages de points efficaces -- qui révèlent les motifs, les clusters et les valeurs aberrantes sans devenir un fouillis -- nécessite plus qu'un simple appel à plt.scatter(). Vous avez besoin du mappage de couleurs pour les catégories, de l'encodage de taille pour une troisième variable, d'étiquettes d'axes appropriées et de la gestion des points qui se chevauchent.

Le plt.scatter() de Matplotlib gère tout cela avec un riche ensemble de paramètres. Ce guide couvre tout, des nuages de points basiques aux techniques avancées comme les graphiques à bulles, les lignes de régression et les matrices de nuages de points multipanneaux.

📚

    Nuage de Points Basique

    import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(100)
y = 2 * x + np.random.randn(100) * 0.5
 
plt.figure(figsize=(8, 6))
plt.scatter(x, y)
plt.xlabel('Valeurs X')
plt.ylabel('Valeurs Y')
plt.title('Nuage de Points Basique')
plt.show()

    Personnalisation des Marqueurs

    import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(50)
y = np.random.randn(50)
 
plt.figure(figsize=(8, 6))
plt.scatter(x, y,
    s=100,              # taille du marqueur
    c='steelblue',      # couleur
    marker='o',         # forme du marqueur
    alpha=0.7,          # transparence
    edgecolors='black', # couleur du bord
    linewidths=0.5,     # largeur du bord
)
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Nuage de Points Personnalisé')
plt.show()

    Formes de Marqueurs Courantes

    MarqueurSymboleDescription
    'o'CerclePar défaut
    's'Carré
    '^'Triangle haut
    'D'Losange
    '*'Étoile
    '+'Plus
    'x'Croix
    '.'PointPetit, pour données denses

    Couleur par Catégorie

    import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
n = 50
 
# Trois catégories
categories = ['A', 'B', 'C']
colors = ['#e74c3c', '#3498db', '#2ecc71']
 
plt.figure(figsize=(8, 6))
for cat, color in zip(categories, colors):
    x = np.random.randn(n) + (categories.index(cat) * 2)
    y = np.random.randn(n) + (categories.index(cat) * 1.5)
    plt.scatter(x, y, c=color, label=cat, alpha=0.7, s=60, edgecolors='white')
 
plt.xlabel('Caractéristique 1')
plt.ylabel('Caractéristique 2')
plt.title('Nuage de Points Coloré par Catégorie')
plt.legend()
plt.show()

    Mappage de Couleur (Variable Continue)

    Utilisez le paramètre c avec un tableau numérique et une palette de couleurs pour encoder une troisième variable en couleur :

    import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(200)
y = np.random.randn(200)
values = x ** 2 + y ** 2  # Distance depuis l'origine
 
plt.figure(figsize=(8, 6))
scatter = plt.scatter(x, y, c=values, cmap='viridis', s=50, alpha=0.8)
plt.colorbar(scatter, label="Distance depuis l'Origine")
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Nuage de Points avec Mappage de Couleur')
plt.show()

    Palettes de Couleurs Populaires

    PaletteTypeIdéal Pour
    'viridis'SéquentielPar défaut, perceptuellement uniforme
    'plasma'SéquentielContraste élevé
    'coolwarm'DivergentValeurs positives/négatives
    'RdYlGn'DivergentPlages bon/mauvais
    'Set1'QualitatifDonnées catégorielles

    Encodage de Taille (Graphique à Bulles)

    Encodez une troisième variable comme taille de marqueur pour créer un graphique à bulles :

    import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
countries = ['US', 'China', 'India', 'Germany', 'Japan', 'UK', 'Brazil', 'France']
gdp = np.array([21.43, 14.34, 2.87, 3.86, 5.08, 2.83, 1.87, 2.72])
population = np.array([331, 1402, 1380, 83, 126, 67, 213, 67])
growth = np.array([2.3, 5.8, 6.5, 1.1, 0.8, 1.4, 1.2, 1.5])
 
plt.figure(figsize=(10, 7))
scatter = plt.scatter(gdp, growth,
    s=population * 2,   # Mise à l'échelle de la population pour des tailles visibles
    c=range(len(countries)),
    cmap='tab10',
    alpha=0.6,
    edgecolors='black',
)
 
for i, country in enumerate(countries):
    plt.annotate(country, (gdp[i], growth[i]),
        textcoords="offset points", xytext=(10, 5), fontsize=9)
 
plt.xlabel('PIB (Billions USD)')
plt.ylabel('Taux de Croissance du PIB (%)')
plt.title('PIB vs Taux de Croissance (taille des bulles = population)')
plt.show()

    Ajouter une Ligne de Régression

    import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(100) * 3
y = 1.5 * x + np.random.randn(100) * 2
 
# Ajuster la régression linéaire
coefficients = np.polyfit(x, y, 1)
poly = np.poly1d(coefficients)
x_line = np.linspace(x.min(), x.max(), 100)
 
plt.figure(figsize=(8, 6))
plt.scatter(x, y, alpha=0.6, s=40, label='Données')
plt.plot(x_line, poly(x_line), 'r-', linewidth=2,
    label=f'y = {coefficients[0]:.2f}x + {coefficients[1]:.2f}')
 
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Nuage de Points avec Ligne de Régression')
plt.legend()
plt.show()

    Gestion des Points Superposés

    Lorsque les points se chevauchent fortement, utilisez la transparence, des marqueurs plus petits ou des techniques basées sur la densité :

    import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(5000)
y = np.random.randn(5000)
 
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
 
# Méthode 1 : Transparence
axes[0].scatter(x, y, alpha=0.1, s=10)
axes[0].set_title('Transparence Alpha')
 
# Méthode 2 : Petits marqueurs
axes[1].scatter(x, y, s=1, c='black')
axes[1].set_title('Petits Marqueurs')
 
# Méthode 3 : Histogramme 2D (hexbin)
axes[2].hexbin(x, y, gridsize=30, cmap='YlOrRd')
axes[2].set_title('Densité Hexbin')
 
plt.tight_layout()
plt.show()

    Sous-graphiques Multiples

    import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
n = 100
 
fig, axes = plt.subplots(2, 2, figsize=(10, 10))
 
# Graphique 1 : Linéaire
x1 = np.random.randn(n)
axes[0, 0].scatter(x1, 2 * x1 + np.random.randn(n) * 0.5, c='steelblue', s=30)
axes[0, 0].set_title('Relation Linéaire')
 
# Graphique 2 : Quadratique
x2 = np.linspace(-3, 3, n)
axes[0, 1].scatter(x2, x2**2 + np.random.randn(n) * 0.5, c='coral', s=30)
axes[0, 1].set_title('Relation Quadratique')
 
# Graphique 3 : Clusters
for i, c in enumerate(['red', 'blue', 'green']):
    cx = np.random.randn(30) + i * 3
    cy = np.random.randn(30) + i * 2
    axes[1, 0].scatter(cx, cy, c=c, s=30, alpha=0.7)
axes[1, 0].set_title('Données Regroupées')
 
# Graphique 4 : Aucune corrélation
axes[1, 1].scatter(np.random.randn(n), np.random.randn(n), c='purple', s=30, alpha=0.5)
axes[1, 1].set_title('Aucune Corrélation')
 
plt.tight_layout()
plt.show()

    Nuages de Points Interactifs avec PyGWalker

    Pour l'analyse exploratoire des données, les nuages de points statiques ne sont que le point de départ. PyGWalker (opens in a new tab) transforme votre DataFrame pandas en une interface interactive de type Tableau directement dans Jupyter. Vous pouvez glisser des colonnes sur les axes, ajouter des encodages de couleur et de taille, et filtrer les données -- le tout sans écrire de code supplémentaire :

    import pandas as pd
import pygwalker as pyg
 
df = pd.DataFrame({'x': x, 'y': y, 'category': np.random.choice(['A', 'B', 'C'], len(x))})
walker = pyg.walk(df)

    Référence des Paramètres de plt.scatter()

    ParamètreTypeDescription
    x, ytype tableauPositions des données
    sscalaire ou tableauTaille(s) de marqueur en points^2
    ccouleur ou tableauCouleur(s) de marqueur. Tableau pour palette
    markerstrStyle de marqueur ('o', 's', '^', etc.)
    cmapstr ou ColormapPalette de couleurs quand c est numérique
    alphafloat (0-1)Transparence
    edgecolorscouleurCouleur du bord du marqueur
    linewidthsfloatLargeur du bord du marqueur
    vmin, vmaxfloatLimites de la plage de la palette
    labelstrÉtiquette de légende

    FAQ

    Comment créer un nuage de points dans Matplotlib ?

    Utilisez plt.scatter(x, y) où x et y sont des tableaux de même longueur. Ajoutez plt.xlabel(), plt.ylabel() et plt.title() pour les étiquettes. Appelez plt.show() pour afficher le graphique.

    Comment colorer les points d'un nuage de points par catégorie ?

    Itérez sur les catégories et appelez plt.scatter() pour chacune avec un paramètre c différent et un label. Puis appelez plt.legend() pour afficher la légende. Alternativement, passez un tableau numérique à c avec une palette de couleurs pour un coloriage continu.

    Comment ajouter une ligne de tendance à un nuage de points ?

    Utilisez np.polyfit(x, y, degré) pour ajuster un polynôme, créez un np.poly1d() à partir des coefficients et tracez-le avec plt.plot(). Pour degré=1, cela donne une ligne de régression linéaire.

    Quelle est la différence entre plt.scatter() et plt.plot() ?

    plt.scatter() crée des marqueurs individuels avec un contrôle point par point sur la taille, la couleur et la forme. plt.plot() avec un style de marqueur crée des points connectés avec une apparence uniforme. Utilisez scatter() quand les points nécessitent un style individuel ; utilisez plot() pour les graphiques linéaires ou les marqueurs uniformes.

    Comment gérer les points superposés dans un nuage de points ?

    Utilisez alpha (transparence) pour révéler la densité, réduisez la taille s des marqueurs, utilisez plt.hexbin() pour les cartes de chaleur de densité, ou décalez légèrement les points avec de petits décalages aléatoires.

    Conclusion

    Le plt.scatter() de Matplotlib est l'outil standard pour créer des nuages de points en Python. Pour l'exploration basique, un simple plt.scatter(x, y) suffit. Pour des figures de qualité publication, exploitez le mappage de couleurs pour les catégories, l'encodage de taille pour une troisième variable, les lignes de régression pour les tendances et la transparence pour les données denses. Maîtrisez ces techniques et vous pourrez visualiser efficacement toute relation bivariée.

    📚