Introduction à NumPy, SciPy et MatplotLib

1

M.IGGANE

Python pour le calcul scientifique

2

Introduction

• Le langage Python seul ne sait pas faire grand chose dans le domaine mathématique, comme tracer une fonction, calculer des valeurs de fonctions usuelles, réaliser des opérations matricielles,...
• De nombreux modules ont été développés pour pallier ce manque, parmi lesquels on convient de citer :

1. numpy: Outil pour créer , manipuler, et appliquer des nombreuses opérations sur les tableaux (matrices)

2. scipy : Boîte à outils numérique pour les tableaux numpy (algèbre linéaire, statistique, intégration,….)

3. matplotlib: Librairie pour le tracé de graphes de fonctions

​

Introduction

3

Introduction

Introduction: Comment Importer un module?

• Un module est un fichier ayant pour extension .py contenant des définitions de constantes et fonctions. Tout programmeur python peut réaliser un module.
• Importer un module permet d'utiliser ses constantes et fonctions. Nous avons deja utilise plusieurs modules : math, random, time.
• Exemples:

1. Pour importer une fonction et une constante

>>> from math import cos , pi

>>> cos(pi/4)

0.7071067811865476

​

2. Pour importer toute la bibliothèque

>>> from math import *

>>> sin(pi/4)

0.7071067811865476

3. Fonctions et constantes doivent être précédées par le nom du module suivi d’un point

>>> import math

>>> math.cos(math.pi/4)

0.7071067811865476

4. On peut définir un alias a l'aide de l'instruction as :

>>> import math as mth # Création d'un alias mth

>>> mth.sqrt(2)

1.4142135623730951

Introduction: Comment Importer un module?

4

Introduction

Le module numpy

5

NumPy

Opérations sur les tableaux numpy

6

NumPy

​

• Le module numpy permet de créer, de manipuler, des tableaux de nombres, ou matrices, et de leur appliquer des opérations mathématiques courantes.

• Le module numpy ajoute le type array qui est similaire à une liste (list) avec la condition supplémentaire que tous les éléments sont du même type, et la taille du tableau est fixée à la création.

​

• Dans toute la suite, on supposera que le module numpy est importé de la manière suivante: >>> import numpy as np

​

• Quand on veut utiliser la fonction « array » par exemple, on pensera toujours à l’utiliser avec la syntaxe « np.array »

Le module numpy

7

NumPy

Création d’un tableau numpy

>>> t1=np.array([1,2,3]) # tableau 1D (entiers)

>>> t1

array([1, 2, 3])

>>> t2=np.array([1,2,3],float) # tableau 1D (réels)

>>> t2

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

>>> t3=np.array([1,2,3],complex) # tableau 1D (complexes)

>>> t3

array([ 1.+0.j, 2.+0.j, 3.+0.j])

>>> t4=np.array([[1,2,3],[3,8,9]]) # tableau 2D

>>> t4

array([[1, 2, 3],

[3, 8, 9]])

Création d’un tableau numpy

La fonction arange() crée une matrice ligne de façon assez analogue a la façon dont range() crée une liste, a ceci près que les coefficients ne sont pas forcement entiers :

>>> v = np.arange(0, 1.5, 0.5)

>>> v

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

​

>>> a = np.arange(25) # Tableau 1D à 25 éléments

>>> a.reshape((5,5)) # changé en tableau 2D à 5*5 éléments

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

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

[10, 11, 12, 13, 14],

[15, 16, 17, 18, 19],

[20, 21, 22, 23, 24]])

8

NumPy

Création d’un tableau numpy

• La fonction linspace(a,b,n) permet de créer un tableau 1d dont les n composantes sont uniformément réparties entre a et b :

>>> np.linspace( 0 , 1 , 5 ) # vecteur à 5 composantes équiréparties entre 0 et 1

array([ 0. , 0.25 , 0.5 , 0.75 , 1. ])

​

• Ces tableaux admettent quelques attributs: par exemple, les fonctions size et shape qui renvoient le nombre d’éléments et la taille du tableau.

>>> B = np.array( [[1,2,3] , [1,4,9]] )

>>> np.size(B)

6

>>> np.shape(B)

(2,3)

​

9

NumPy

Création d’un tableau numpy: tableaux spécifiques

>>> np.zeros(5) # tableau 1d de 0

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

​

>>> np.ones((2,4)) # tableau 2d de taille 2 x 4 contenant des 1

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

[ 1., 1., 1., 1.]])

​

>>> np.eye(3) # matrice identité 3 x 3 equivalent à np.eye(3,3)

array([[ 1., 0., 0.],

[ 0., 1., 0.],

[ 0., 0., 1.]])

​

>>> np.eye(3, 2, dtype=int)

array([[ 1 , 0],

[ 0 , 1],

[ 0 , 0]])

​

10

NumPy

Création d’un tableau numpy: tableaux spécifiques

>>> np.identity(3) # matrice identité 3 x 3 equivalent à np.eye(3,3)

array([[ 1., 0., 0.],

[ 0., 1., 0.],

[ 0., 0., 1.]])

>>> np.diag(np.ones(3))

array([[ 1., 0., 0.],

[ 0., 1., 0.],

[ 0., 0., 1.]])

>>> A = np.array([[1,2,3],[4,5,6],[7,8,9]]) # un tableau 2d

>>> A

array( [ [ 1 , 2 , 3 ],

[ 4 , 5 , 6 ],

[ 7 , 8 , 9 ] ])

>>> np.diag(A) # extraction de la diagonale principale

array([1, 5, 9])

>>> np.diag(A,k=-1) # extraction de la sous-diagonale

array([4, 8])

11

NumPy

Accès aux éléments d’un tableau numpy:

>>> v = np.array(range(0,160,10))

>>> v

array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150])

>>> v[0] # le 1er élément

0

>>> v[-1] # le dernier élément

150

>>> v[4 :11] # de v[4] à v[10]

array([40, 50, 60, 70,80, 90, 100])

>>> v[ 11 : 4 : -1 ] # de v[11] à v[5], donc |4-11| = 7 éléments

array([110, 100, 90, 80, 70, 60, 50])

>>> v[ 6 : : -1 ] # de v[6] à v[0], donc 7 éléments

array([60, 50, 40, 30, 20, 10, 0])

12

NumPy

Accès aux éléments d’un tableau numpy:

>>> m = np.array( [ [ 10*i + j for j in range(7) ] for i in range(4) ] )

>>> m

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

[10, 11, 12, 13, 14, 15, 16],

[20, 21, 22, 23, 24, 25, 26],

[30, 31, 32, 33, 34, 35, 36]])

>>> m[3,5] # element en position (3,5)

35

>>> m[3] # vecteur-ligne en position 3

array([30, 31, 32, 33, 34, 35, 36])

>>> m[ : , 5] # vecteur-colonne en position 5

array([ 5, 15, 25, 35])

>>> m[1 : 3 , 2 : 6] # lignes 1 à 3, colonnes 2 à 5

array( [[12, 13, 14, 15],

[22, 23, 24, 25]] )

13

NumPy

Remarque:

Comme les listes, les matrices sont des objets mutables.

>>> A=np.array([[ 1, 1],[-1, 0]])

>>> B=A

>>> A[1,1]=2

>>> A

array([[ 1, 1],

[-1, 2]])

>>> B

array([[ 1, 1],

[-1, 2]])

Pour éliminer ce problème, il faut faire une copie de la matrice A :

>>> A=np.array([[ 1, 1],[-1, 0]])

>>> B=np.array(A,copy=True)

>>> A[1,1]=2

>>> A

array([[ 1, 1],

[-1, 2]])

>>> B

array([[ 1, 1],

[-1, 0]])

14

NumPy

Opérations sur les tableaux numpy:

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

>>> s = array( [ [0,0,7] , [6,6,6] ] )

>>> t

array( [ [1,2,3] ,

[4,5,6] ] )

>>> s

array( [ [0,0,7] ,

[6,6,6] ] )

>>> s+t

array([[ 1, 2, 10],

[10, 11, 12]])

>>> s-t

array([[-1, -2, 4],

[ 2, 1, 0]])

>>> s*t

array([[ 0, 0, 21],

[24, 30, 36]])

>>> s**2

array([[ 0, 0, 49],

[36, 36, 36]])

15

NumPy

Toutes ces opérations agissent case par case, entre tableaux de même format. Sur le plan syntaxique, elle sont classiquement notées à l’aide des opérateurs +, -, * et /.

Calcul matriciel:

16

NumPy

• Le produit matriciel s'obtient a l'aide de la fonction dot().

​

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

>>> dot (A, np.eye(2)) # syntaxe correcte du produit matriciel

array([[ 1., 2.],

[ 3., 4.]])

>>> A * np.eye(2) # Faux( produit terme à terme)

array([[ 1., 0.],

[ 0., 4.]])

• Le déterminant d’une matrice à l’aide np.linalg.det():

>>> np.linalg.det ( [ [1 , 2] , [3 , 4] ] )

-2.0000000000000004

Calcul matriciel:

17

NumPy

• L’inverse d’une matrice s'obtient a l'aide de la fonction np.linalg.inv().

​

>>> A=np.array( [ 2 , 4 , 6 , 8 ] , float ).reshape( 2 , 2 )

>>> np.linalg.inv( A )

array([[-1. , 0.5 ],

[ 0.75, -0.25]])

Remarque 1: il faut d’abord savoir si la matrice est inversible pour l’inverser, ou encore rester critique vis à vis du résultat retourné.

Remarque 2: Notez bien que si B est l’inverse de A , alors le produit matriciel de A et de B (np.dot(A,B)) doit donner une matrice ayant 1 sur le diagonal principal et 0 partout ailleurs.

------>Problème de représentation des nombres réels dans les ordinateurs

Calcul matriciel:

18

NumPy

• Résolution d’un système d’équations linéaires s'obtient a l'aide de la fonction np.linalg.solve().

Exemple: x + 3y + 5z = 10

2x + 5y + z = 8

2x + 3y + 8z = 3

Ce dernier peut être représenté sous la forme A x = b, où

​

​

​

>>> A = np.array([ [1.0,3.0,5.0], [2.0,5.0,1.0], [2.0,3.0,8.0] ])

>>> b = np.array([10.0, 8.0, 3.0])

>>> x = np.linalg.solve(A, b)

>>> x

array([-9.28 , 5.16 , 0.76])

Calcul matriciel:

19

NumPy

• Transposé d’une matrice s’obtient à l'aide de la fonction np.transpose().

​

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

>>>A

array( [ [ 1 , 2 ] ,

[ 3 , 4 ] ] )

>>>np.transpose (A)

array( [ [ 1 , 3 ] ,

[ 2 , 4 ] ] )

array(l) crée un tableau a partir d'une liste l

arange(a,b,k) crée un vecteur dont les coefs sont les a+k.N entre a (inclu) et b (exclu)

linspace(a,b,n) crée un vecteur de n valeurs regulierement espacees entre a et b (inclus)

zeros(p) crée un tableau de taille p rempli de zeros

zeros((p,q)) crée un tableau de taille (p,q) rempli de zeros

ones(p) crée un tableau de taille p rempli de uns

ones((p,q)) crée un tableau de taille (p,q) rempli de uns

shape() pour obtenir la taille d'un tableau (= type d'une matrice)

size() pour obtenir le nombre d'elements d'un tableau

reshape() pour redimensionner un tableau

dot() pour effectuer un produit matriciel de 2 matrices

vdot() pour effectuer un produit scalaire de 2 "vecteurs"

transpose() pour transposer une matrice

rank() rang d'une matrice

mean() valeur moyenne d'un tableau

​

linalg :

inv() inversion d'une matrice

det() déterminant d'une matrice

solve(A,b) résolution du système linéaire A.X = b

​

numpy contient aussi constantes et fonctions mathématiques usuelles.

Le module numpy:

20

NumPy

Le module matplotlib

21

MatplotLib

Graphiques

22

Le module matplotlib:

22

MatplotLib

• Il est possible d’afficher des graphiques avec Python en utilisant plusieurs bibliothèques. La plus connue est matplotlib
• Pour le simple trace de courbes nous n'utiliserons que le sous-module pyplot, importé, avec alias, a l'aide de la commande :

>>> import matplotlib.pyplot as plt

• Les fonctions essentielles de pyplot sont :

plot() pour le tracé de points, de courbes, et

show() pour afficher le graphique crée.

• Utiliser plot() avec :

en 1er argument la liste des abscisses,

en 2eme argument la liste des ordonnées,

en 3eme argument (optionnel) le motif des points,…

Le module matplotlib:

23

• Exemple : courbe de la fonction sinus

import matplotlib.pyplot as plt

import numpy as np

x=np.linspace(-5,5,100)

plt.plot(x,np.sin(x)) # on utilise la fonction sinus de numpy

plt.ylabel("fonction sinus")

plt.xlabel("l’axe des abcisses")

plt.show()

MatplotLib

• numpy permet de “vectoriser”, i.e. appliquer une fonction à un vecteur/matrice et éviter les boucles. Comme nous avons choisi d’utiliser numpy , il faut choisir les fonctions usuelles définies dans numpy.

from math import sin

plt.plot(x,sin(x)) -----> Erreur

Le module matplotlib:

24

MatplotLib

Le module matplotlib:

25

MatplotLib

Exemple : la courbe de la fonction

def f(t) : # définition de la fonction

return np.sin(5*t) * np.exp(t)

x = np.linspace(-np.pi, np.pi, 100) # création des tableau abscisses et ordonnées

y = f(x)

plt.plot(x, y)

plt.grid() # décoration : pour créer une grille

plt.title('Le graphe de $f$') # Le titre

plt.xlabel('$x$') # le nom de l'axe horizontal

plt.ylabel('$y=f(x)$')

plt.axhline(color='black') #equivalent a linewidth=1, color='k')

plt.axvline(color='black')

plt.savefig('courbe1.pdf') # pour sauver (en pdf ou autre)

plt.show()

Le module matplotlib:

26

MatplotLib

Le module scipy

27

SciPy

Intégration numérique && Equations différentielles

Le module scipy: Intégration numérique

28

Scipy

• Le module scipy réalise les différentes opérations sur des tableaux numériques (array) de numpy.
• On peut donc directement utiliser ces tableaux comme arguments pour les différentes fonctions
• La méthode quad(f,a,b) pour intégrer f sur l'intervalle [a; b] :

Exemple:

>>> from scipy import integrate

>>>f = lambda x: x**2

>>> integrate.quad( f , 0 , 1 )

(0.33333333333333337, 3.700743415417189e-15)

Elle retourne un couple constitué de la valeur approchée de l'intégrale (1er élément) et d'une estimation de l'erreur commise.

29

SciPy

Le module scipy: Intégration numérique

Exemple:

Pour intégrer une fonction complexe nous devons la définir.

>>> f = lambda x: np.sin(x) + np.cos(x) ** 2

>>> integrate.quad(f, 0, 100) # L’intégrale de f dans [0; 100]

(49.919356803408775, 1.6173704855766236e-08)

>>> integrate.quad(f, 100, 10) # L’intégrale de f dans [100; 10]

(-42.85204896165046, 5.421224073487639e-10)

30

SciPy

Le module scipy: Équations différentielles

La bibliothèque scipy.integrate contient la fonction odeint, qui résout numériquement des équations différentielles. On commence donc par la charger :

>>>from scipy.integrate import odeint

​

Le principe d’utilisation de odeint (pour intégrer numériquement des équations différentielles) est le suivant : pour avoir une estimation numérique de la solution du problème : sur un intervalle [t0 , tf]. Il faut définir :

• La variable ‘t’ est de la forme t=[ t0,t1,..., tf].
• La condition initiale est alors : y(t0) = y0.

La valeur renvoyée est un tableau contenant une estimation de la solution aux différents temps.

Une fois définies, on peut utiliser odeint:

>>>yt = odeint(f, y0, t)

31

SciPy

Le module scipy: Équations différentielles

Prenons l'exemple de l'intégration sur [-1; 1] de l'E.D : y’ = t avec y(-1) = 1/2.

dont l'unique solution est y(t) = t²/ 2

>>> t = np.linspace(-1,1,100)

>>> f = lambda y, t : t

>>> y0 = 1/2.

>>> y = odeint(f, y0, t)

>>> plt.plot(t,y)

>>> plt.grid()

>>> plt.show()

32

SciPy

Le module scipy: Équations différentielles

Il correspond bien au résultat attendu : y(t) = t2/ 2 sur l’intervalle [-1; 1]