Graphiques linéaires et nuages de points
Représentez les données continues avec ax.plot() et les points discrets avec ax.scatter(), en contrôlant la couleur, le marqueur et le style de ligne.
Graphiques linéaires et nuages de points est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Graphiques linéaires et nuages de points : types fondamentaux
Les graphiques linéaires relient les points de données successifs par une ligne et sont idéaux pour visualiser les tendances au fil du temps ou les fonctions continues. Les nuages de points représentent les points individuellement sans les relier, ce qui les rend parfaits pour explorer les relations entre deux variables numériques. Les deux types de graphiques sont créés sur un objet Matplotlib Axes : ax.plot() pour les lignes et ax.scatter() pour les points.
ax.plot() pour les graphiques linéaires
ax.plot(x, y) trace une ligne qui relie les points de données dans leur ordre. Transmettez les valeurs de x comme premier argument et celles de y comme deuxième argument. Les deux peuvent être des listes Python, des tableaux NumPy ou des séries Pandas. Lorsqu'un seul argument est transmis, Matplotlib utilise automatiquement l'index (0, 1, 2, ...) comme axe des x. Cette méthode renvoie une liste d'objets Artist Line2D.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2 * np.pi, 100)
y = np.sin(x)
fig, ax = plt.subplots(figsize=(7, 4))
ax.plot(x, y) # basic line plot
ax.set_title('Sine Wave')
ax.set_xlabel('x')
ax.set_ylabel('sin(x)')
# plt.show()
plt.close()Contrôler le style et la couleur des lignes
Les arguments nommés les plus courants de ax.plot() sont : color (nom, code hexadécimal ou tuple RGB), linewidth (ou lw), linestyle (ou ls) : '-' continu, '--' discontinu, ':' en pointillés, '-.' mixte, marker (forme à chaque point de données) et markersize. Combinez linestyle et marker pour afficher simultanément la ligne et les points de données individuels.
fig, ax = plt.subplots(figsize=(7, 4))
# Solid blue line with circle markers
ax.plot(x, np.sin(x), color='steelblue', lw=2, ls='-',
marker='o', markersize=4, label='sin(x)')
# Dashed red line
ax.plot(x, np.cos(x), color='crimson', lw=1.5, ls='--', label='cos(x)')
ax.legend()
plt.close()Tracer plusieurs lignes
Appelez ax.plot() plusieurs fois pour superposer plusieurs lignes sur les mêmes Axes. Matplotlib parcourt automatiquement une palette de couleurs par défaut. Transmettez toujours l'argument nommé label pour chaque ligne afin que ax.legend() puisse les étiqueter automatiquement. Placez l'appel à la légende après tous les appels de traçage pour vous assurer que toutes les lignes sont incluses.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0)
dates = pd.date_range('2024-01', periods=12, freq='ME')
fig, ax = plt.subplots(figsize=(8, 4))
for product in ['A', 'B', 'C']:
sales = np.random.randint(50, 200, 12)
ax.plot(dates, sales, marker='o', label=f'Product {product}')
ax.set_title('Monthly Sales by Product')
ax.legend()
plt.close()Tracer directement des DataFrames Pandas
Les DataFrames Pandas disposent d'une méthode .plot() qui crée directement des graphiques Matplotlib. Transmettez ax=ax pour dessiner sur un objet Axes existant. df.plot(ax=ax) trace toutes les colonnes sous forme de lignes distinctes en utilisant l'index du DataFrame comme axe des x. Vous pouvez ensuite appliquer toutes les personnalisations de Matplotlib à l'objet ax.
df = pd.DataFrame(
np.random.randn(12, 3),
index=pd.date_range('2024', periods=12, freq='ME'),
columns=['North', 'South', 'West']
).cumsum()
fig, ax = plt.subplots(figsize=(8, 4))
df.plot(ax=ax, linewidth=1.5)
ax.set_title('Cumulative Revenue by Region')
ax.set_ylabel('Revenue (cumulative)')
plt.close()ax.scatter() pour les nuages de points
ax.scatter(x, y) trace des points individuels sans les relier. Contrairement à ax.plot(), scatter ne suppose pas que les données sont ordonnées. Paramètres principaux : c (couleur, qui peut être un tableau pour appliquer une couleur à chaque point), s (taille des points, qui peut également être un tableau), cmap (palette de couleurs lorsque c est numérique) et alpha (transparence de 0 à 1 pour gérer la superposition des points).
np.random.seed(42)
x = np.random.randn(100)
y = 2 * x + np.random.randn(100)
fig, ax = plt.subplots(figsize=(6, 5))
ax.scatter(x, y, color='steelblue', alpha=0.6, s=40)
ax.set_xlabel('Feature X')
ax.set_ylabel('Target Y')
ax.set_title('Feature vs Target')
plt.close()Colorer les points selon une catégorie
Transmettez un tableau numérique au paramètre c et une palette cmap pour colorer les points selon une troisième variable. Ajoutez une barre de couleurs avec plt.colorbar(scatter_obj) afin de fournir une échelle. Cette technique est appelée une variante de graphique à bulles lorsque le paramètre s (taille) varie également selon une quatrième variable.
categories = np.random.choice([0, 1, 2], size=100)
fig, ax = plt.subplots(figsize=(6, 5))
scatter = ax.scatter(x, y, c=categories, cmap='Set1',
alpha=0.7, s=60, edgecolors='none')
fig.colorbar(scatter, ax=ax, label='Category')
ax.set_title('Scatter Coloured by Category')
plt.close()Ajouter une ligne de tendance
Un nuage de points accompagné d'une ligne de tendance ajustée présente à la fois les points de données individuels et la tendance générale. Utilisez np.polyfit(x, y, 1) pour calculer un ajustement linéaire, évaluez-le avec np.poly1d(coeffs)(x_range), puis superposez le résultat avec ax.plot() par-dessus le nuage de points. La ligne de tendance doit être plus fine et avoir un style différent afin de la distinguer des points de données.
fig, ax = plt.subplots(figsize=(6, 5))
ax.scatter(x, y, alpha=0.4, s=30, color='steelblue', label='Data')
# Fit and plot linear trend line
coeffs = np.polyfit(x, y, 1)
x_line = np.linspace(x.min(), x.max(), 100)
y_line = np.poly1d(coeffs)(x_line)
ax.plot(x_line, y_line, color='red', lw=2, label='Linear fit')
ax.legend()
ax.set_title('Scatter with Trend Line')
plt.close()Ombrer les bandes de confiance avec fill_between
ax.fill_between(x, y_lower, y_upper) remplit la zone située entre deux courbes. Cette fonction est couramment utilisée pour représenter des intervalles de confiance autour d'une ligne moyenne, des bandes d'écart type ou des enveloppes min/max. Transmettez alpha pour rendre l'ombrage semi-transparent afin que les données sous-jacentes restent visibles.
x_range = np.linspace(0, 2 * np.pi, 100)
mean = np.sin(x_range)
upper = mean + 0.2
lower = mean - 0.2
fig, ax = plt.subplots(figsize=(7, 4))
ax.plot(x_range, mean, color='steelblue', lw=2, label='Mean')
ax.fill_between(x_range, lower, upper,
color='steelblue', alpha=0.2, label='±0.2 band')
ax.legend()
ax.set_title('Line with Confidence Band')
plt.close()Limites des axes et lignes de grille
Contrôlez la plage visible avec ax.set_xlim(min, max) et ax.set_ylim(min, max). Activez les lignes de grille avec ax.grid(True). Personnalisez la grille à l'aide des arguments nommés linestyle, linewidth et alpha. Une grille discrète avec alpha=0.3 facilite la lecture des valeurs exactes sans alourdir le graphique. Appelez ax.set_axisbelow(True) pour dessiner la grille derrière les points de données.
fig, ax = plt.subplots(figsize=(7, 4))
ax.plot(x, np.sin(x), 'b-', lw=2)
ax.set_xlim(0, 2 * np.pi)
ax.set_ylim(-1.2, 1.2)
ax.grid(True, linestyle='--', alpha=0.5)
ax.set_axisbelow(True) # grid behind data
ax.set_title('Sine with Grid')
plt.close()Alpha et superposition des points
Lorsque de nombreux points de données se chevauchent dans une même zone d'un nuage de points, les points individuels deviennent invisibles : c'est ce qu'on appelle la superposition des points. La solution la plus simple consiste à réduire l'opacité avec alpha (0.0 = totalement transparent, 1.0 = totalement opaque). Définissez alpha=0.3 ou une valeur inférieure afin que les zones denses paraissent plus sombres (car plusieurs points semi-transparents se superposent), tandis que les zones clairsemées restent claires. Pour les ensembles de données très volumineux (des millions de points), envisagez plutôt hexbin ou les estimations de densité par noyau.
np.random.seed(1)
x_dense = np.random.randn(1000)
y_dense = np.random.randn(1000)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))
# Without alpha: overplotting hides density
ax1.scatter(x_dense, y_dense, s=10)
ax1.set_title('No alpha (overplotted)')
# With alpha: density visible
ax2.scatter(x_dense, y_dense, s=10, alpha=0.2)
ax2.set_title('alpha=0.2 (density visible)')
plt.tight_layout()
plt.close()Vérification rapide
Vérifiez votre compréhension des graphiques linéaires et des nuages de points dans Matplotlib présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que ax.plot() crée des graphiques linéaires avec un contrôle complet de la couleur, du style de ligne et des marqueurs ; ax.scatter() crée des nuages de points dont la couleur et la taille peuvent être définies pour chaque point via c et s ; ax.fill_between() ajoute des bandes de confiance ; et ax.grid() ajoute des lignes de grille pour faciliter la lecture. Ensuite, nous créerons des graphiques à barres et des histogrammes pour visualiser des données catégorielles et des distributions.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Graphiques linéaires et nuages de points » est-elle gratuite ?
Oui — le texte complet de « Graphiques linéaires et nuages de points » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Graphiques linéaires et nuages de points » ?
Représentez les données continues avec ax.plot() et les points discrets avec ax.scatter(), en contrôlant la couleur, le marqueur et le style de ligne. Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?
Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Graphiques linéaires et nuages de points » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?
Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Architecture des figures et des axes
- Graphiques linéaires et nuages de points
- Graphiques en barres et histogrammes
- Libellés, titres et enregistrement des figures