Divers modules permettent de tracer des courbes d'équation $y = f(x)$. On utilisera ici le module pyplot de matplotlib – voir documentation.

Pour représenter graphiquement une fonction $f$ sur un segment $[a, b]$ on peut construire une subdivision $(a_i)_{0\leqslant i\leqslant n}$ de $[a,b]$ avec $a_i= a +i \,\frac{b-a}{n}$, soit en Python :

X = [a+i*(b-a)/n for i in range(n+1)]

À partir de la subdivision précédente, on peut calculer les images $f(x)$ correspondantes, ce qui est immédiat en Python :

Y = [f(x) for x in X]

Il reste à demander l'affichage. Pour cela on fournit les tableaux X et Y à la fonction plot et on peut également ajouter des options de mise en forme : plot(X, Y, options).

On obtient la ligne brisée reliant les points de coordonnées $(a_i\,;\,f(a_i))_{0 \leqslant i \leqslant n}$. Bien sûr, si on choisit n = len(X) assez grand, cette ligne donne l'illusion d'une courbe douce.

import matplotlib.pyplot as plt

def dessin(f, a, b, n):
    """
    Affiche la représentation graphique de f sur [a;b]
    """
    X = [a + i*(b-a)/n for i in range(n+1)]
    Y = [f(x) for x in X]
    plt.figure()
    plt.plot(X, Y, 'r')
    plt.show()

# Création d'une fonction
f1 = lambda x: x**3 - 3*x**2 + x - 5

# On aurait aussi bien pu faire :
'''
def f1(x):
    return x**3 - 3*x**2 + x - 5
'''

dessin(f1, -3, 5, 100)

• En ligne 1, as plt est un alias (pseudonyme) : On n'a pas envie d'écrire ici et là matplotlib.pyplot alors on crée l'alias plt, ainsi on n'aura qu'à écrire plt à la place.
• En ligne 9, plt.figure() ouvre une nouvelle figure. Cela peut servir suivant si on souhaite placer plusieurs courbes sur un même graphique ou pas.
• En ligne 10, 'r' indique que la courbe sera en rouge – r pour red
• En ligne 11, plt.show() provoque l'affichage d'une fenêtre pour la figure – graphique – ou plusieurs si on en a créé plusieurs figures. Notez bien que :
  • rien ne s'affiche si on n'appelle pas plt.show()
  • plt.show() ouvre la fenêtre graphique et suspend l'exécution du programme. Il faut fermer la fenêtre pour que le programme reprenne son cours.
  • La fenêtre dispose de commandes permettant de sauvegarder le résultat, ajuster la vue… Pensez-y : Python et matplotlib vous permettront de produire des graphiques très nettement supérieurs à ceux d'un tableur !

Numpy est un module incontournable de Python. Il contient énormément de fonctions très puissantes. Numpy propose notamment des tableaux très performants utilisés en analyse de données – data science – traitement d'images…

• arrange(a, b, h) crée la subdivision démarrant en x = a et poursuivant par pas h avec x ⇐ b. Par exemple en posant h = (b-a)/n, on obtient la subdivision de la partie précédente.
• linspace(a,b,n) crée une subdivision de n points, ce qui revient à faire n-1 intervalles de (a-b)/(n-1). Pour obtenir la subdivision précédente, il faudrait donc linspace(a,b,n+1). Mais en ce +1 ne change en général pas grand chose – si on prend 600 points, un de plus ou de moins…

Exemple

import matplotlib.pyplot as plt
import numpy as np

def f(x):
    if x == 0:
        return 1
    return np.sin(x)/x

plt.figure()
X = np.linspace(-15, 15, 600)
Y = [f(x) for x in X]
plt.plot(X, Y, 'b')
plt.axhline(linewidth=2, color='k')
plt.axvline(linewidth=2, color='k')
plt.title('la fonction f(x)= sin(x)/x')
plt.axis([-15, 15, -0.5, 1.3])
plt.show()

• Ligne 7, Numpy fournit les fonctions usuelles comme sin, pas besoin d'aller chercher sin dans le module math.
• Ligne 10, X est un tableau mais un tableau spécial, un tableau Numpy. Pour un usage basique, on ne verra pas la différence avec un tableau de type list.

X est un tableau spécial, un tableau Numpy.

En ligne 11, on crée Y comme dans l'exemple précédent, Y = [f(x) for x in X].

On aurait pu faire plus court en écrivant Y = f(X). C'est possible car dans f, on utilise np.sin qui est fait exprès pour des données vectorialisée – sous forme de tableau.

Si f n'avait pas déjà été vectorialisée (par exemple si f utilisait des calculs inadaptés à un tableau Numpy) on pourrait la vectorialiser en créant une version : fvec = np.vectorialize(f).

On pourrait penser que vectorialiser ne change pas grand chose, que ce n'est qu'un gadget typographique. Eh bien c'est plus que cela : Numpy est optimisé dans un langage plus rapide que Python si bien que si on utilise les mécanismes de Numpy, l'exécution sera beaucoup plus rapide.

À vous de représenter quelques fonctions bien choisies sur des intervalles pertinents, après interaction visuelle avec les retours du logiciel, en utilisant de manière pertinente et efficace les fonctions et les méthodes du module pyplot.

On peut aussi, représenter, pour ceux qui savent ce que c’est, des arcs paramétrés, des courbes planes définies par une équation cartésienne, des courbes et des surfaces, en perspective, dans l’espace à trois dimensions, des lignes de niveaux, des figures géométriques de toutes sortes. Tout ceci est désormais en dehors du programme de mathématiques.

import matplotlib.pyplot as plt
import numpy as np
plt.figure()
T = np.linspace(0, 6.28, 100)
X = np.cos(2*T)
Y = np.sin(3*T)
plt.plot(X, Y, 'b')
plt.show()