Tracer des courbes avec matplotlib

Tracer des courbes en Python

Dans la fiche précédente, tu as représenté une suite par un nuage de points : pour chaque $n$ entier, un point $(n, u_n)$. Une fonction $f$ se représente, elle, par une courbe continue. En Python, on triche un peu : on échantillonne $f$ sur de très nombreuses valeurs de $x$ et on relie les points par des segments. À l'œil, le résultat est indissociable d'une vraie courbe.

À la fin de cette fiche, tu sauras générer un tableau d'abscisses avec numpy, tracer la courbe représentative d'une fonction avec plt.plot, habiller le graphique (titre, axes, grille, légende), superposer plusieurs courbes, et tracer des courbes paramétriques.

De la suite à la courbe

Une fonction $f : \mathbb{R} \to \mathbb{R}$ a une infinité d'images. Impossible de toutes les calculer. L'astuce : on choisit un grand nombre de valeurs $x_0, x_1, \dots, x_n$ régulièrement espacées dans un intervalle, on calcule les $f(x_i)$, et on demande à plt.plot de relier les points consécutifs par un segment. Avec 200 ou 500 points, l'œil voit une courbe lisse.

Cette première version utilise une compréhension de liste, exactement comme dans la fiche sur les suites. Ça marche très bien pour 60 points. Mais dès qu'il faut en générer 1000 ou écrire $\sin(x)$ pour chaque $x$, la solution devient lourde. C'est là qu'intervient numpy.

import matplotlib.pyplot as plt

abscisses = [-2 + 0.1 * k for k in range(41)]
ordonnees = [x ** 3 for x in abscisses]

plt.plot(abscisses, ordonnees)
plt.grid(True)
plt.show()

import matplotlib.pyplot as plt

abscisses = [0.1 * k for k in range(51)]
ordonnees = [2 * x + 1 for x in abscisses]

plt.plot(abscisses, ordonnees)
plt.grid(True)
plt.show()

import matplotlib.pyplot as plt

abscisses = [-3 + 0.05 * k for k in range(121)]
ordonnees = [-x ** 2 + 4 for x in abscisses]

plt.plot(abscisses, ordonnees)
plt.grid(True)
plt.show()

numpy : un tableau d'abscisses en une ligne

numpy est la bibliothèque scientifique de référence en Python. Sa fonction linspace(a, b, n) crée un tableau de $n$ valeurs régulièrement réparties entre $a$ et $b$ (bornes incluses). Plus besoin de calculer le pas à la main.

Le résultat est un ndarray (tableau numpy), pas une liste Python ordinaire. Sa force : les opérations arithmétiques s'appliquent à tout le tableau d'un coup, sans boucle. C'est la vectorisation.

Pour tracer une courbe, on combine linspace et la vectorisation. Le code devient nettement plus court et plus rapide :

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 100)
y = x ** 3 - 3 * x

plt.plot(x, y)
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-2 * np.pi, 2 * np.pi, 300)
y = np.sin(x)

plt.plot(x, y)
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 400)
y = 1 / (1 + x ** 2)

plt.plot(x, y)
plt.grid(True)
plt.show()

Habiller un graphique

Une courbe sans titre ni axes étiquetés, c'est un graphique inutilisable. matplotlib propose une série d'instructions à appeler avant plt.show() :

• plt.title("...") — un titre
• plt.xlabel("...") et plt.ylabel("...") — étiquettes des axes
• plt.grid(True) — quadrillage
• plt.axhline(0, color='black') — axe horizontal noir
• plt.axvline(0, color='black') — axe vertical noir
• plt.xlim(a, b) et plt.ylim(c, d) — bornes des axes

Pour la couleur et le style du tracé, plot accepte des arguments comme color (noms ou codes hex), linestyle ('--', ':', '-.') et linewidth.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 200)
y = x ** 2 - 4

plt.plot(x, y)
plt.title('Parabole')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-2 * np.pi, 2 * np.pi, 300)
y = np.cos(x)

plt.plot(x, y, linestyle='--', color='red')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 9, 200)
y = np.sqrt(x)

plt.plot(x, y, color='teal')
plt.title('Racine carrée')
plt.xlabel('x')
plt.ylabel('sqrt(x)')
plt.ylim(0, 4)
plt.grid(True)
plt.show()

Plusieurs courbes sur un même graphique

Pour comparer deux fonctions, on appelle plt.plot plusieurs fois avant le plt.show(). Chaque appel ajoute une courbe à la figure courante. On utilise l'argument label et la fonction plt.legend() pour identifier chaque courbe.

Cette technique est très utile pour visualiser une résolution graphique : tracer $y = f(x)$ et $y = g(x)$ sur le même repère, puis lire les abscisses des points d'intersection.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-2 * np.pi, 2 * np.pi, 300)

plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.legend()
plt.grid(True)
plt.show()

Courbes paramétriques

Une courbe paramétrique se décrit par deux fonctions du temps : $x(t)$ et $y(t)$. Tracer la courbe revient alors à tracer le nuage des points $(x(t), y(t))$ pour $t$ parcourant un intervalle. C'est exactement la même API : plt.plot(x_array, y_array).

L'astuce plt.gca().set_aspect('equal') force les axes à la même échelle : sans elle, le cercle aurait l'air d'une ellipse aplatie. Tu peux aussi tracer des courbes plus exotiques :

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(0, 2 * np.pi, 200)
x = 3 * np.cos(t)
y = 1 * np.sin(t)

plt.plot(x, y)
plt.gca().set_aspect('equal')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(0, 8 * np.pi, 500)
x = t * np.cos(t)
y = t * np.sin(t)

plt.plot(x, y)
plt.gca().set_aspect('equal')
plt.show()

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(0, 2 * np.pi, 500)
x = np.sin(3 * t)
y = np.sin(2 * t)

plt.plot(x, y)
plt.gca().set_aspect('equal')
plt.title('Lissajous 3:2')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-3, 3, 200)

for c in range(-3, 4):
    plt.plot(x, x ** 2 + c, label=f'c = {c}')
plt.legend()
plt.grid(True)
plt.title('Famille y = x² + c')
plt.show()