Graphiques en ligne Matplotlib en Python — Guide complet

La fonction plot() de Matplotlib est l'outil de référence pour les graphiques en ligne — des graphiques qui relient des points de données par une ligne continue afin de montrer des tendances dans le temps ou selon une variable continue. Ce chapitre couvre tout, de votre premier tracé de sinusoïde aux touches professionnelles comme les annotations, les régions ombrées et la sauvegarde de fichiers prêts pour la publication.

Avant de commencer, assurez-vous que Matplotlib est installé :

pip install matplotlib

Si vous débutez avec cette bibliothèque, consultez d'abord les chapitres Introduction à Matplotlib et Premiers pas.

Quand utiliser un graphique en ligne

Utilisez un graphique en ligne lorsque :

• Vous souhaitez montrer des tendances dans le temps (cours des actions, températures mensuelles, perte d'entraînement par époque).
• L'axe des x représente une variable continue ou ordonnée (temps, distance, fréquence).
• Vous devez comparer plusieurs séries partageant le même axe des x.

Évitez les graphiques en ligne pour des catégories non ordonnées — un graphique à barres est plus clair dans ce cas. Pour la relation entre deux variables numériques indépendantes sans ordre implicite, envisagez plutôt un nuage de points.

Créer un graphique en ligne de base

La signature minimale est plt.plot(x, y). x et y peuvent être des listes Python ou des tableaux NumPy.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)   # 100 evenly-spaced points from 0 to 10
y = np.sin(x)

plt.plot(x, y)

plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.title('Sine Wave')

plt.tight_layout()
plt.show()

np.linspace(start, stop, num) retourne num valeurs régulièrement espacées — une façon pratique de générer des courbes lisses sans écrire de boucle. plt.tight_layout() ajuste l'espacement pour que les étiquettes des axes ne soient jamais tronquées ; il est conseillé de l'inclure avant chaque appel à show() ou savefig().

Changer la couleur et le style de la ligne

Utiliser le raccourci de chaîne de format

Passez une chaîne de format '[couleur][marqueur][style de ligne]' comme troisième argument positionnel :

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y, 'r--')   # red dashed line

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Red Dashed Sine Wave')
plt.tight_layout()
plt.show()

Lettres de couleur courantes : b bleu, g vert, r rouge, c cyan, m magenta, y jaune, k noir, w blanc.

Codes de style de ligne courants : - continu (défaut), -- tirets, -. tiret-point, : pointillés.

Utiliser des paramètres nommés

Les paramètres nommés sont plus lisibles et offrent un contrôle plus fin :

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(
    x, y,
    color='steelblue',
    linestyle='--',
    linewidth=2,
)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Styled Line')
plt.tight_layout()
plt.show()

Ajouter des marqueurs aux points de données

Les marqueurs dessinent un symbole à chaque point de données, ce qui est utile lorsque les données brutes comportent peu de points et que vous souhaitez les afficher explicitement.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 9)   # only 9 points — markers are visible
y = np.sin(x)

plt.plot(
    x, y,
    color='darkorange',
    linewidth=1.5,
    marker='o',          # circle marker
    markersize=8,
    markerfacecolor='white',
    markeredgewidth=1.5,
)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave with Markers')
plt.tight_layout()
plt.show()

Codes de marqueurs courants : 'o' cercle, 's' carré, '^' triangle vers le haut, 'D' losange, '+' plus, 'x' croix, '*' étoile.

Consultez le chapitre Marqueurs Matplotlib pour la liste complète et les options de mise en forme avancées.

Tracer plusieurs lignes

Appelez plt.plot() plusieurs fois avant plt.show(). Chaque appel ajoute une nouvelle ligne aux mêmes axes. Passez un argument label puis appelez plt.legend() pour générer automatiquement une légende.

import matplotlib.pyplot as plt
import numpy as np

x  = np.linspace(0, 10, 200)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.sin(x) * np.exp(-x / 5)   # damped sine

plt.plot(x, y1, label='sin(x)', linewidth=1.5)
plt.plot(x, y2, label='cos(x)', linewidth=1.5, linestyle='--')
plt.plot(x, y3, label='damped sin(x)', linewidth=1.5, linestyle='-.')

plt.xlabel('x')
plt.ylabel('y')
plt.title('Multiple Lines')
plt.legend()

plt.tight_layout()
plt.show()

Matplotlib parcourt automatiquement sa palette de couleurs par défaut, vous n'avez donc pas besoin de spécifier des couleurs différentes pour chaque ligne, sauf si vous souhaitez les remplacer.

Contrôler les limites des axes

plt.xlim() et plt.ylim() définissent la plage visible de chaque axe. Passez (min, max) pour zoomer en avant ou en arrière :

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y)

plt.xlim(0, 5)     # show only the first half
plt.ylim(-1.2, 1.2)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave (Zoomed In)')
plt.tight_layout()
plt.show()

Pour laisser Matplotlib déterminer automatiquement une borne tout en fixant l'autre, utilisez None comme espace réservé : plt.xlim(None, 5) laisse la borne inférieure automatique.

Ajouter une grille

plt.grid(True) ajoute une grille légère qui facilite la lecture des valeurs sur le graphique. Vous pouvez cibler uniquement les graduations majeures ou mineures et contrôler le style :

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y, color='steelblue', linewidth=2)

plt.grid(True, linestyle='--', color='grey', alpha=0.5)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave with Grid')
plt.tight_layout()
plt.show()

Consultez le chapitre Grille Matplotlib pour une discussion complète sur la personnalisation des grilles.

Annoter des points

plt.annotate() dessine une étiquette textuelle avec une flèche optionnelle pointant vers une coordonnée de données spécifique. C'est utile pour mettre en évidence des pics, des creux ou des événements significatifs.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y, color='steelblue', linewidth=1.5)

# Annotate the first peak (approx. x = pi/2)
plt.annotate(
    'peak',
    xy=(np.pi / 2, 1),            # point to annotate
    xytext=(np.pi / 2 + 1, 1.1),  # position of the text
    arrowprops=dict(arrowstyle='->', color='black'),
    fontsize=10,
)

plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Annotated Sine Wave')
plt.tight_layout()
plt.show()

Remplir entre des lignes

plt.fill_between() ombre la région entre deux courbes (ou entre une courbe et une constante). C'est courant pour afficher des intervalles de confiance ou des bandes d'incertitude.

import matplotlib.pyplot as plt
import numpy as np

x    = np.linspace(0, 10, 200)
y    = np.sin(x)
# Simulate an upper and lower confidence bound
upper = y + 0.3
lower = y - 0.3

plt.plot(x, y, color='steelblue', linewidth=2, label='mean')
plt.fill_between(x, lower, upper, alpha=0.2, color='steelblue', label='±0.3 band')

plt.xlabel('x')
plt.ylabel('Amplitude')
plt.title('Line with Confidence Band')
plt.legend()
plt.tight_layout()
plt.show()

L'argument alpha contrôle la transparence de l'ombre — des valeurs autour de 0.2–0.3 fonctionnent généralement bien pour que la ligne reste clairement visible.

Utiliser l'API orientée objet

Tous les exemples ci-dessus utilisent l'interface sans état plt.*, pratique pour les scripts à tracé unique. Pour des figures plus complexes (plusieurs sous-graphiques, graphiques imbriqués), utilisez l'API orientée objet où vous travaillez avec des objets Figure et Axes explicites :

import matplotlib.pyplot as plt
import numpy as np

x  = np.linspace(0, 10, 200)
y1 = np.sin(x)
y2 = np.cos(x)

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

ax.plot(x, y1, label='sin(x)', color='steelblue', linewidth=1.5)
ax.plot(x, y2, label='cos(x)', color='darkorange', linewidth=1.5, linestyle='--')

ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('OO-style Line Plot')
ax.legend()
ax.grid(True, linestyle=':', alpha=0.6)

plt.tight_layout()
plt.show()

L'API orientée objet reproduit les appels plt.* avec les préfixes ax.set_* pour les étiquettes et les titres. C'est le style préféré lorsque vous devez organiser plusieurs graphiques — consultez Sous-graphiques Matplotlib pour plus de détails.

Sauvegarder un graphique en ligne dans un fichier

Utilisez plt.savefig() avant plt.show(). Spécifiez le format de fichier par l'extension :

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)
y = np.sin(x)

plt.plot(x, y, color='steelblue', linewidth=2)
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Saved Line Plot')
plt.tight_layout()

plt.savefig('sine_wave.png', dpi=150)    # raster PNG at 150 dpi
plt.savefig('sine_wave.svg')             # vector SVG (ideal for web/print)

plt.show()

Options de format courantes : png, pdf, svg, eps. Utilisez svg ou pdf lorsque vous avez besoin d'une image vectorielle prête à imprimer. Appelez savefig() avant show() — après show(), la figure est effacée et savefig() produirait une image vide.

Contrôler la taille de la figure

La figure par défaut est de 6,4 × 4,8 pouces à 100 dpi. Remplacez-la avec figsize=(largeur_in, hauteur_in) :

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 200)

fig, ax = plt.subplots(figsize=(10, 4))   # wide and short
ax.plot(x, np.sin(x), label='sin', linewidth=1.5)
ax.plot(x, np.cos(x), label='cos', linewidth=1.5, linestyle='--')

ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('Wide Figure')
ax.legend()

plt.tight_layout()
plt.show()

Référence rapide

Chapitres connexes

• Introduction à Matplotlib — vue d'ensemble de la bibliothèque et installation
• Matplotlib Pyplot — l'interface pyplot en profondeur
• Marqueurs Matplotlib — formes et mise en forme des marqueurs
• Étiquettes Matplotlib — étiquettes des axes, titres et annotations
• Grille Matplotlib — ajouter et styliser les lignes de grille
• Nuages de points Matplotlib — relations entre deux variables
• Graphiques à barres Matplotlib — comparer des quantités entre catégories
• Sous-graphiques Matplotlib — plusieurs graphiques dans une seule figure