Calcul scientifique

avec Python
Introduction
Matlab (pour Matrix laboratory) est un logiciel de calcul
numérique commercialisé par la société MathWorks.
Il a été développé à la fin des années 70.

C'est un langage pour le calcul scientifique, l’analyse de

données, leur visualisation, le développement d’algorithmes.

Matlab trouve ses applications dans de nombreuses disciplines scientifiques.

Il constitue un outil numérique puissant pour :

● la modélisation de systèmes physiques,
● la simulation de modèles mathématiques,
● la conception et la validation (tests en simulation) d’applications.

Le logiciel de base peut être complété par de multiples toolboxes qui sont des bibliothèques
de fonctions dédiées à des domaines particuliers, comme par exemple :
● l’automatique,
● le traitement du signal,
● le traitement d'image,
● les télécommunications
● l'analyse de données financières,
● l’analyse statistique...

Le prix d'une licence Matlab : <~ 100 € pour la version éducation

>~ 2500 € pour la version industrielle

Au prix de la licence, il faut ajouter celui de chaque toolbox commandée...

Introduction

Au début des années 90, des solutions alternatives à Matlab en open-source sous
licence GPL ont été développées :

SciLab

Octave

Leur syntaxe ressemble beaucoup à celle de Matlab.

Introduction

De base, le langage Python n’intègre pas de type particulier pour les tableaux.

Les tableaux peuvent être vus comme des listes (1D) ou des listes de listes (2D).

La librairie NumPy propose une multitude de fonctions destinées à la manipulation et

aux calculs sur les tableaux (matrices).

NumPy a beaucoup de choses en commun avec Matlab, mais NumPy a été créé
pour fonctionner avec le langage Python, pas pour être un clone de Matlab.

Cette librairie permet au programmeur Python d'intégrer du calcul scientifique dans

son code.

NumPy peut être couplée à la librairie Matplotlib qui est destinée à tracer et
visualiser des données sous forme de graphiques.

Il existe aussi l’interface PyLab qui repose sur NumPy et Matplotlib, et qui propose
un style de programmation plus simple, se rapprochant encore davantage de celui
de Matlab.
Introduction

SciPy

La librairie SciPy (Scientific Python) est dédiée aux calculs mathématiques complexes
pour la résolution de problèmes scientifiques.

Scipy utilise les tableaux et matrices du module Numpy.

Il contient par exemple des modules pour faire :

de l'optimisation,
de l'algèbre linéaire,
de la transformée de Fourier,
du calcul d’intégrales
des calculs statistiques,
du traitement du signal,
du traitement d'images...

Scipy peut être couplé à Matplotlib pour offrir des possibilités avancées de visualisation.
Utilisation de la librairie NumPy
Qu’est ce que NumPy ?

NumPy est une bibliothèque qui permet la manipulation de tableaux en Pyhton.

NumPy utilise le style de la programmation orientée objet.

Un tableau est un objet sur lequel on peut appliquer des méthodes (fonctions).

Syntaxe : objet.méthode()

Ces tableaux pourront être utilisés comme des vecteurs ou des matrices grâce à
des fonctions de NumPy qui permettent de réaliser des calculs matriciels utilisés en
algèbre.
Comment importer le module NumPy ?

NumPy n’est pas une librairie standard de Python.

Avant de pouvoir l’utiliser il faut l’installer sur la machine.

Elle est téléchargeable gratuitement sur internet.

Pour pouvoir utiliser NumPy dans un programme, il faut commencer par l’importer.

Dans la syntaxe « standard », on importe la totalité du module numpy et on lui

donne un allias pour alléger ensuite l’écriture de l’appel des fonctions.

L’allias qui est le plus couramment utilisé est np.

import numpy as np

Maintenant que le module est importé, ses fonctions peuvent être utilisées dans le
programme.
Comment créer un tableau avec NumPy ?

Pour créer un tableau, nous utilisons la méthode numpy.array().

Création d’un tableau monodimensionnel (1D)

Pour créer un tableau 1D, il suffit de passer une liste de nombres en argument de la
méthode array().

Cette méthode convertit la liste en un tableau.

>>> a = np.array([4, 7, 9])

>>> a
array([4, 7, 9])

Pour connaître le type de la variable a, on utilise la fonction type() :

>>> type(a)
<class 'numpy.ndarray'>

On constate ici que ce type est bien défini dans le module numpy, et qu’il s’agit
effectivement d’un tableau (ndarray = N-dimensional array).
Comment créer un tableau avec NumPy ?

Création d’un tableau bidimensionnel (2D)

Pour créer un tableau 2D, il suffit de transmettre une liste de listes à la méthode
numpy.array().

>>> a = np.array([[1, 2, 3], [4, 5, 6]])

>>> a
array([[1, 2, 3],
[4, 5, 6]])

On a ainsi créé un tableau à 2 lignes et 3 colonnes, qui contient donc 6 éléments.

Remarque :

Dans un programme, la définition d’un tableau peut-être écrite sur plusieurs lignes
pour en faciliter la lecture :

a = np.array([[1, 2, 3],
[4, 5, 6]])
Comment connaître la taille d’un tableau avec NumPy ?

La fonction standard len() peut être utilisée pour connaître la taille d’un tableau.

Pour connaître le nombre de lignes, il suffit de demander la taille de la liste qui

encapsule les autres (qui correspondent aux différentes lignes) :

>>> a = np.array([[1, 2, 3], [4, 5, 6]])

>>> len(a)
2

Il y a bien deux lignes dans le tableau.

Pour connaître le nombre de colonnes, il suffit de demander la taille de l’une ou

l’autre des listes encapsulées (elles ont normalement toutes la même taille) :

>>> len(a[0])
3

>>> len(a[1])
3

Il y a bien 3 colonnes dans le tableau.

Comment accéder à un élément d’un tableau avec NumPy ?

L’accès à un élément d’un tableau se fait de la même manière que pour les listes.

Pour accéder à l’élément qui se trouve sur la ligne l et la colonne c, on utilise la

notation indicielle :

tableau[l][c]

>>> a = np.array([[1, 2, 3], [4, 5, 6]])

>>> a[0][0]
1
>>> a[0][1]
2
>>> a[0][2]
3
>>> a[1][0]
4
>>> a[1][1]
5
>>> a[1][2]
6
Comment accéder à un élément d’un tableau avec NumPy ?

Des indices négatifs peuvent être utilisés pour accéder aux éléments du tableau.

La ligne d’indice 0 étant aussi la ligne d’indice -len(tableau).

La ligne d’indice len(tableau) - 1 étant aussi la ligne d’indice -1.

La même règle s’applique lors de l’accès aux colonnes.

>>> a = np.array([[1, 2, 3], [4, 5, 6]])

>>> a[-1][0]
4
>>> a[-2][2]
3
>>> a[0][-2]
2
>>> a[1][-3]
4
>>> a[-1][-2]
5
>>> a[-2][-1]
3
Comment accéder à un élément d’un tableau avec NumPy ?

Toute tentative d’accès à un élément d’indice situé en dehors de l’intervalle

[-len(tableau), len(tableau) - 1] déclenche une exception.

>>> a = np.array([[1, 2, 3], [4, 5, 6]])

>>> a[0][3]
Traceback (most recent call last):
File "<pyshell>", line 1, in <module>
IndexError: index 3 is out of bounds for axis 0 with size 3

>>> a[2][0]
Traceback (most recent call last):
File "<pyshell>", line 1, in <module>
IndexError: index 2 is out of bounds for axis 0 with size 2
Céation automatique d’un tableau avec NumPy ?

La méthode numpy.arange() retourne un objet de type numpy.ndarray (1D) contenant

des valeurs entières déterminées à partir des valeurs de ses paramètres (start, stop et
step).

Elle suit le même principe que la fonction range() mais retourne un tableau au lieu
d’une séquence.

La valeur stop est exclue du tableau.

Par défaut, si le paramètre start n'est pas précisé, il prend la valeur 0.

Par défaut, si le paramètre step n’est pas précisé, il prend la valeur 1.

>>> np.arange(0, 6, 1) équivalent à np.arange(6)

array([0,1, 2, 3, 4, 5])

>>> np.arange(1, 6, 2)
array([1, 3, 5])

>>> np.arange(-5, 6)
array([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5])

>>> np.arange(10, 0, -1) Dans ce cas start > stop...

array([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])
Céation automatique d’un tableau avec NumPy ?

La méthode numpy.linspace() retourne aussi un objet de type numpy.ndarray (1D)

contenant un nombre donné de valeurs réelles espacées régulièrement et calculées à
partir de ses paramètres (start, stop et nombre).

>>> np.linspace(0, 5, 11)

array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. ])

>>> np.linspace(-3, 3, 7)
array([-3., -2., -1., 0., 1., 2., 3.])
Comment connaître le nombre d’éléments d’un tableau avec NumPy ?

La méthode numpy.size() renvoie le nombre d’éléments du tableau (indépendamment

du nombre de lignes et de colonnes) :

>>> a = np.array([2, 5, 6, 8])

>>> np.size(a)
4

>>> b = np.array([[1, 2, 3], [4, 5, 6]])

>>> np.size(b)
6
Comment connaître la taille d’un tableau avec NumPy ?

La méthode numpy.shape() (forme, en anglais) renvoie la taille du tableau.

Elle renvoie un tuple contenant le nombre de lignes suivi du nombre de colonnes.

>>> a = np.array([2, 5, 6, 8])

>>> np.shape(a)
(4,)

Il s’agit d’un tableau à une seule ligne de 4 éléments.

>>> b = np.array([[1, 2, 3], [4, 5, 6]])

>>> np.shape(b)
(2, 3)

Il s’agit d’un tableau à 2 lignes de 3 éléments.

Comment connaître la taille d’un tableau avec NumPy ?

L'attribut shape d'un tableau permet aussi de connaître sa taille.

Il renvoie un tuple contenant le nombre de lignes suivi du nombre de colonnes.

>>> a = np.array([2, 5, 6, 8])

>>> a.shape
(4,)

Il s’agit d’un tableau à une seule ligne de 4 éléments.

>>> b = np.array([[1, 2, 3], [4, 5, 6]])

>>> b.shape
(2, 3)

Il s’agit d’un tableau à 2 lignes de 3 éléments.

Comment modifier la taille d’un tableau avec NumPy ?

Il est possible de changer la taille d’un tableau en utilisant l’attribut shape de ce tableau
(à ne pas confondre avec la méthode numpy.shape() qui elle retourne la taille du
tableau...).

>>> a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> a
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> np.shape(a)
(9, )

>>> a.shape = (3, 3)

>>> a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

>>> np.shape(a)
(3, 3)
Comment modifier la taille d’un tableau avec NumPy ?

La nouvelle taille du tableau doit être compatible avec le nombre d'éléments du

tableau d'origine...

>>> a = np.array([1, 2, 3, 4, 5, 6, 7, 8])

>>> a
array([1, 2, 3, 4, 5, 6, 7, 8])

>>> np.shape(a)
(8, )

>>> a.shape = (3, 3)

Traceback (most recent call last):
File "<pyshell>", line 1, in <module>
ValueError: cannot reshape array of size 8 into shape (3,3)
Tranche de tableau (ou slicing) avec NumPy

Lors de la manipulation des tableaux, on a souvent besoin de récupérer une partie d’un
tableau.

Python permet d’extraire des tranches d’un tableau grâce à la technique du slicing.

Le slicing sur les tableaux fonctionne de la même manière que sur les listes ou sur les
tuples, en précisant les indices de début et de fin de tranche.

Dans la tranche [n:m], l’élément d’indice n est inclus, mais pas celui d’indice m.

Il est aussi possible de définir le pas de slicing (égal à 1 par défaut).

>>> t = np.array([0, 1, 2, 3, 4, 5, 6])

>>> t[2:5] >>> t[2:5:2]

array([2, 3, 4]) array([2, 4])

>>> t[:3] >>> t[::3]

array([0, 1, 2]) array([0, 3, 6])

>>> t[4:] >>> t[:]

array([4, 5, 6]) array([0, 1, 2, 3, 4, 5, 6])
Tranche de tableau (ou slicing) avec NumPy

Le slicing s’applique aussi aux tableaux 2D.

>>> a = np.array([[1, 2, 3],

[4, 5, 6],
[7, 8, 9])

>>> a[1 , : ]
array([4, 5, 6]) Donne un tableau 1D (une ligne) correspondant à la ligne
d’indice 1 (toutes les colonnes) du tableau a.

>>> a[ : , 1]
array([2, 5, 8]) Donne un tableau 1D (une ligne) correspondant à la colonne
d’indice 1 (toutes les lignes) du tableau a.

>>> a[ : , 1:2]
array([[2], Donne un tableau 2D correspondant à la colonne d’indice 1
[5], du tableau a.
[8]])

Pour obtenir un tableau 2D correpondant à la colonne d’indice n, il faut faire du

slicing en utilisant a[ : , n:n+1]
Tranche de tableau (ou slicing) avec NumPy

Le slicing s’applique aussi aux tableaux 2D.

Si on fait du slicing sur une ligne et une colonne, on obtient l’élément

positionné à l’intersection de cette ligne et de cette colonne...

>>> a = np.array([[1, 2, 3],

[4, 5, 6],
[7, 8, 9])

>>> a[1, 1]
5

C’est équivalent à :

>>> a[1][1]
5
Tranche de tableau (ou slicing) avec NumPy

>>> a = np.array([[1, 2, 3, 4],

[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])

>>> a[1:3, 1:3]

array([[ 6, 7],
[10, 11]])

>>> a[ :2, 1: ]
array([[2, 3, 4],
[6, 7, 8]])
Matrices nulles avec NumPy.

La méthode numpy.zeros() permet de créer une matrice nulle ne contenant que des
zéros.

Utilisée avec un seul argument, cette méthode génère un tableau 1D :

>>> np.zeros(3)
array([0., 0., 0.])

Utilisée avec deux arguments, cette méthode génère un tableau 2D :

>>> np.zeros((2, 3))

array([[0., 0., 0.],
[0., 0., 0.]])

Remarques :

Lorsqu’il y a deux arguments, le paramètre est un tuple.

Les points derrière les 0 indiquent qu’il s’agit de valeurs réelles (type float).
Matrices nulles avec NumPy.

Pour forcer le codage de 0 sous forme de nombres entiers, il suffit d’ajout une option
sur le type :

>>> np.zeros(3, dtype='i')

array([0, 0, 0], dtype=int32)

>>> np.zeros((2, 3), dtype='i')

array([[0, 0, 0],
[0, 0, 0]], dtype=int32)
Matrices de 1 avec NumPy.

La méthode numpy.ones() permet de créer une matrice ne contenant que des uns.

Utilisée avec un seul argument, cette méthode génère un tableau 1D :

>>> np.ones(3)
array([1., 1., 1.])

Utilisée avec deux arguments, cette méthode génère un tableau 2D :

>>> np.ones((2, 3))

array([[1., 1., 1.],
[1., 1., 1.]])

Remarques :

Lorsqu’il y a deux arguments, le paramètre est un tuple.

Les points derrière les 1 indiquent qu’il s’agit de valeurs réelles (type float).
Matrices de 1 avec NumPy.

Pour forcer le codage de 1 sous forme de nombres entiers, il suffit d’ajout une option
sur le type :

>>> np.ones(3, dtype='i')

array([1, 1, 1], dtype=int32)

>>> np.ones((2, 3), dtype='i')

array([[1, 1, 1],
[1, 1, 1]], dtype=int32)
Matrices identité avec NumPy.

En algèbre linéaire, la matrice identité ou matrice unité est une matrice carrée avec
des 1 sur la diagonale et des 0 partout ailleurs.

La méthode numpy.eye() permet de créer ce type de matrice.

Utilisée avec un seul argument, cette méthode génère une matrice carrée (nombre de
lignes égal au nombre de colonnes) :

>>> np.eye(3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

Cette méthode peut être utilisée avec deux arguments pour génèrer une portion de
matrice identité :

>>> np.eye(2, 3)
array([[1., 0., 0.],
[0., 1., 0.]])
Matrices identité avec NumPy.

Pour forcer le codage des 0 et 1 sous forme de nombres entiers, il suffit d’ajout une
option sur le type :

>>> np.eye(3, dtype = 'i')

array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]], dtype=int32)
Matrices identité avec NumPy.

La méthode numpy.identity() offre une autre solution pour générer une matrice
identité :

>>> np.identity(3, dtype=int)

array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
Opérations sur les matrices avec NumPy.

Le module numpy intègre divers fonctions utilisées pour le calcul matriciel.

Par exemple, il est possible de calculer facilement :

 le déterminant d’une matrice

 le produit terme à terme de deux matrices

 le produit matriciel

 l’inverse d’une matrice

 la transposée d’une matrice

 la matrice complexe conjuguée

 Outils utilisés dans de nombreux domaines scientifiques.

Matrices : Algèbre linéaire - Calcul du déterminant avec NumPy.

La méthode numpy.linalg.det() permet de calculer le déterminant d’une matrice.

Pour pouvoir l’utiliser, il faut préalablement l’importer :

>>> from numpy.linalg import det

>>> a = np.array([[1, 0, 6],

[3, 4, 15],
[5, 6, 21]], dtype = 'i')

>>> det(a)
-17.999999999999982
Matrices : produit terme à terme avec NumPy.

Il est possible de réaliser un produit terme à terme grâce à l’opérateur *.

>>> a = np.array([[1, 2, 3],

[4, 5, 6]])

>>> b = np.array([[2, 1, 3],

[3, 2, 1]])

>>> a*b
array([[ 2, 2, 9],
[12, 10, 6]])
Matrices : produit terme à terme avec NumPy.

Le produit terme à terme ne s’applique que sur des matrices de même taille.

>>> a = np.array([[1, 2, 3],

[4, 5, 6]])

>>> b = np.array([[2, 1],

[3, 2]])

>>> a*b
Traceback (most recent call last):
File "<pyshell>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (2,3) (2,2)
Matrices : produit matriciel avec NumPy.

Le produit de deux matrices n’est possible que si le nombre de colonnes de la

première matrice est égal au nombre de lignes de la seconde.

Soient A = (aij) une matrice de type (n, p) et B = (bij) une matrice de type (p, q).

Le produit A.B est une matrice C = (cij) de type (n, q) avec :

Le produit matriciel est obtenu à l’aide de la méthode numpy.dot().

>>> a = np.array([[1, 2, 3],

[4, 5, 6]])

>>> b = np.array([[4],
[2],
[1])

>>> np.dot(a, b)
array([[11],
[32]])
Matrices : produit matriciel avec NumPy.

Vérifier les tailles des matrices avant de calculer le produit matriciel.

>>> a = np.array([[1, 2],

[4, 5]])

>>> b = np.array([[4],
[2],
[1])

>>> np.dot(a, b)
Traceback (most recent call last):
File "<pyshell>", line 1, in <module>
File "<__array_function__ internals>", line 6, in dot
ValueError: shapes (2,2) and (3,1) not aligned: 2 (dim 1) != 3 (dim 0)
Matrices : Algèbre linéaire - Calcul de la matrice inverse avec NumPy.

La matrice inverse d’une matrice carrée A d’ordre n est la matrice B d’ordre n notée :

B = A-1

telle que : AB = BA = In (produit matriciel)

où In désigne la matrice identité d’ordre n.

Une matrice carrée est inversible si et seulement si son déterminant est non nul.

La méthode numpy.linalg.inv() permet de calculer l'inverse d’une matrice.

Pour pouvoir l’utiliser, il faut préalablement l’importer :

>>> from numpy.linalg import inv

Matrices : Algèbre linéaire - Calcul de la matrice inverse avec NumPy.

>>> from numpy.linalg import inv

>>> A = np.array([[1, 3, 3],

[1, 4, 3],
[1, 3, 4]])
>>> det(A)
1.0

>>> B = inv(A)

>>> B
array([[ 7., -3., -3.],
[-1., 1., 0.],
[-1., 0., 1.]])

>>> np.dot(A, B)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

>>> np.dot(B, A)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
Matrices : Résolution d’un système d’équations linéaires avec NumPy.

Un système d’équations linéaires peut se résoudre à l’aide du calcul matriciel.

La méthode numpy.linalg.solve() permet de résoudre ce type de système.

Soit le système d’équations linéaire suivant :

x–y+z=3
2x + y – z = 0
x + 2y + z = 4

>>> A = np.array([[1, -1, 1], Coefficients des inconnus

[2, 1, -1],
[1, 2, 1]])

>>> B = np.array([3, 0, 4]) Membres de droite des équations du système

>>> S = np.linalg.solve(A, B)

>>> S
array([1. , 0.33333333, 2.33333333])
Action d’une fonction mathématique sur un tableau avec NumPy.

NumPy dispose d’un grand nombre de fonctions mathématiques qui peuvent être
appliquées directement à un tableau.

Dans ce cas, la fonction est appliquée à chacun des éléments du tableau.

>>> x = np.linspace(-np.pi/2, np.pi/2, 3)

>>> x
array([-1.57079633, 0. , 1.57079633]) (valeurs des angles en radians)

>>> y = np.sin(x)

>>> y
array([-1., 0., 1.])

Remarque : Il est possible d'obtenir les angles en degrés avec la méthode np.degrees()

>>> z = np.degrees(x)

>>> z
array([-90., 0., 90.])
Utilisation de la librairie matplotlib
Tracé de courbes sous matplotlib

Pour pouvoir tracer des graphiques, il faut commencer par importer le module pyplot.

import matplotlib.pyplot as plt

On importe le module pyplot de matplolib sous le nom de plt, pour qu’il soit plus facile
de l’utiliser après.

Cette importation ne doit se faire qu’une seule fois dans notre document.

Il n’est pas nécessaire de la refaire pour chaque figure, mais il est indispensable de
ne pas l’oublier avant la première utilisation d’une fonction du module.
Tracé de courbes sous matplotlib

Pour commencer, nous allons tracer une courbe avec en ordonnées des valeurs
contenues dans une liste et en abscisses, leur indice.

plt.plot([11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
plt.show()

La fonction plot permet de générer le graphique à partir de la liste de valeurs, et la

fonction show permet d’afficher ce graphique.
Tracé de courbes sous matplotlib

La liste des ordonnées peut être contenue dans une variable :

y = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
plt.plot(y)
plt.show()
Tracé de courbes sous matplotlib

Il est bien sûr possible de préciser les valeurs des abscisses, en les stockant dans une
liste :

x = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109]
y = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
plt.plot(x, y)
plt.show()
Tracé de courbes sous matplotlib

Les valeurs des abscisses et des ordonnées peuvent être contenues dans des
tableaux numpy :

x = np.array([100, 101, 102, 103, 104, 105, 106, 107, 108, 109])
y = np.array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
plt.plot(x, y)
plt.show()
Tracé de courbes sous matplotlib

Les valeurs des abscisses peuvent être obtenues à l’aide de la fonction arange de
numpy :

x = np.arange(100, 110, 1)
y = np.array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
plt.plot(x, y)
plt.show()
Tracé de courbes sous matplotlib

Les valeurs des ordonnées peuvent être calculées à partir des valeurs des abscisses :

x = np.arange(0, 11, 1)
y = x ** 2
plt.plot(x, y)
plt.show()
Tracé de courbes sous matplotlib

Les valeurs des ordonnées peuvent être calculées à partir des valeurs des abscisses
directement dans les paramètres de la fonction plot :

x = np.arange(0, 11, 1)
plt.plot(x, x ** 2)
plt.show()
Tracé de courbes sous matplotlib

Nous aurions pu obtenir un résultat similaire à l'aide de la fonction linspace qui calcule
les points en les espaçant régulièrement dans un intervalle donné en fonction du
nombre de points souhaité :

x = np.linspace(0, 10, 5)
plt.plot(x, x ** 2)
plt.show()
Tracé de courbes sous matplotlib

La résolution du tracé dépend du nombre de points générés par la fonction linspace :

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

plt.plot(x, x ** 2)
plt.show()
Tracé de courbes sous matplotlib

La fonction plot peut recevoir d’autres paramètres pour gérer l’affichage de la courbe :

plot(x, y, color, marker, markersize, linestyle, linewidth, label)

Un ou plusieurs paramètres peuvent être utilisés simultanément.

Le paramètre color (chaîne de caractères) permet de définir la couleur du tracé.

De nombreuses couleurs peuvent être utilisées. Quelques exemples :

Tracé de courbes sous matplotlib

Pour afficher la courbe en rouge :

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

plt.plot(x, x ** 2, color = ‘r’)
plt.show()
Tracé de courbes sous matplotlib

Le paramètre marker (chaîne de caractères) permet de définir la forme des marqueurs.

Tracé de courbes sous matplotlib

Pour afficher la courbe en rouge avec des marqueurs de forme carré :

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

plt.plot(x, x ** 2, color = ‘r’, marker = ‘s’)
plt.show()
Tracé de courbes sous matplotlib

Le paramètre markersize permet de définir la taille des marqueurs (nombre flottant) :

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

plt.plot(x, x ** 2, color = ‘r’, marker = ‘s’, markersize = 10)
plt.show()
Tracé de courbes sous matplotlib

Le paramètre linestyle permet de définir le style de ligne utilisé pour le tracé :

Tracé de courbes sous matplotlib

Le paramètre linestyle permet de définir le style de ligne utilisé pour le tracé :

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

plt.plot(x, x ** 2, color = ‘r’, marker = ‘s’, markersize = 4, linestyle = ‘:’)
plt.show()
Tracé de courbes sous matplotlib

Le paramètre linewidth (nombre flottant) permet de définir l’épaisseur de ligne utilisée

pour le tracé :

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

plt.plot(x, x ** 2, color = ‘m’, linewidth = 10)
plt.show()
Tracé de courbes sous matplotlib

Le paramètre label (chaîne de caractères) permet de définir une étiquette associée à

la courbe. La fonction legend doit ensuite être utilisée pour afficher l’étiquette :

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

plt.plot(x, x ** 2, color = ‘m’, label = ‘y = x^2’)
plt.legend()
plt.show()
Tracé de courbes sous matplotlib

La fonction grid permet d’afficher un quadrillage sur le graphique :

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

plt.plot(x, x ** 2, color = ‘m’, label = ‘y = x^2’)
plt.legend()
plt.grid()
plt.show()
Tracé de courbes sous matplotlib

La fonction grid peut recevoir plusieurs paramètres :

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

plt.plot(x, x ** 2, color = ‘m’, label = ‘y = x^2’)
plt.legend()
plt.grid(color = ‘b’, linestyle = ‘--’, linewidth = 0.75)
plt.show()
Tracé de courbes sous matplotlib

Les fonctions xlabel et ylabel permettent de définir les étiquettes d’axe (chaîne de
caractères). Ces fonctions peuvent recevoir d’autres paramètres :

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

plt.plot(x, x ** 2, color = ‘m’, label = ‘y = x^2’)
plt.legend()
plt.grid(color = ‘b’, linestyle = ‘--’, linewidth = 0.75)
plt.xlabel(‘x’, color = ‘r’)
plt.ylabel(‘y = x^2’, color = ‘r’)
plt.show()
Tracé de courbes sous matplotlib

La fonction title permet d’afficher un titre sur le graphique (chaîne de caractères).

Cette fonction peut recevoir d’autres paramètres :

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

plt.plot(x, x ** 2, color = ‘m’, label = ‘y = x^2’)
plt.legend()
plt.grid(color = ‘b’, linestyle = ‘--’, linewidth = 0.75)
plt.xlabel(‘x’, color = ‘r’)
plt.ylabel(‘y = x^2’, color = ‘r’)
plt.title(‘Ma première courbe’, color = ‘c’)
plt.show()
Tracé de courbes sous matplotlib

Il est aussi possible d’afficher plusieurs courbes sur un même graphique :

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

plt.plot(x, x, color = ‘orange’, label = ‘y = x’)
plt.plot(x, x ** 2, color = ‘m’, label = ‘y = x^2’)
plt.plot(x, x ** 3, color = ‘g’, label = ‘y = x^3’)
plt.legend()
plt.grid(color = ‘silver’, linestyle = ‘--’, linewidth = 0.75)
plt.xlabel(‘x’, color = ‘b’)
plt.ylabel(‘y = f(x)’, color = ‘b’)
plt.title(‘Plusieurs courbes...’)
plt.show()
Tracé de courbes sous matplotlib

Autre exemple :

x = np.arange(0, 4 * np.pi , 0.1)

y1 = np.sin(x)
y2 = np.cos(x)
plt.plot(x, y1, 'r', label = 'sin(x)')
plt.plot(x, y2, 'b', label = 'cos(x)')
plt.legend()
plt.grid(color = 'silver', linestyle = '--', linewidth = 0.75)
plt.xlabel('x en radians')
plt.title(‘Fonctions trigonométriques’)
plt.show()