Institut Préparatoire des Etudes d’Ingénieurs de Tunis

Classes : Première année MP/PC

Simulation numérique :
Présentation de la bibliothèque numpy
Manipulation des vecteurs
Dr. Ghabri Afef Année Universitaire : 2020-2021
 Introduction

 Dans cette partie, nous nous intéressons à des méthodes numériques pour la
résolution d’équations sur les réels, de systèmes linéaires et d’équations
différentielles.

 D’une part, nous rappelons les méthodes du cours de mathématiques, qui

sont faciles à programmer, et dont la validité peut être démontrée formellement
et sans grande difficulté. D’autre part, nous expliquons comment utiliser les
fonctions « clés en main » fournies par Python et ses bibliothèques adaptées,
avec des exemples rencontrés en mathématiques, sciences physiques ou
chimie.

1
 Introduction

 On garde à l’esprit que les données prises en entrée sont des approximations
des données « réelles » (parce qu’issues d’autres calculs ou de mesures
physiques). De plus, on résout des équations qui sont une approximation de la
vie réelle (linéarisation d’un phénomène en physique...) et on applique pour
cela des schémas qui introduisent une erreur dans le résultat.

 Enfin, le moindre calcul en arithmétique flottante induit des erreurs d’arrondis.

Nous montrons sous quelles conditions on peut contrôler ces erreurs, et
comment choisir les paramètres des méthodes utilisées pour obtenir un
résultat satisfaisant.

2
 Notion de modules
 Un module est un fichier ayant pour extension « .py » contenant des définitions de
classes, constantes et fonctions. Tout programmeur python peut réaliser un module.

Exemple de modules : math, random, time, numpy, scipy, matplotlib ..

 Pour importer un module dans un programme, il y’a deux méthodes :

o Importation de tous les éléments du module

1) import module 2) from module import *
ex : ex:

import math from math import *

s2 = sin(2)
a = math.sin(2) # pour calculer le sin de 2

o Importation d’une fonction du module

from module import fonction ex :

# pour plusieurs fonctions from math import sin, cos

c2 = cos(2)
from module import fonction1, fonction2
s2 = sin(2)
3
 Module Numpy
Pour le calcul scientifique, on est souvent amené à manipuler de grands ensembles de
nombres. Les listes Python sont des conteneurs hétérogènes qui ne sont pas adaptées
pour cela car :
 Les opérations arithmétiques (addition, multiplication) ne sont pas réalisables
facilement (car le + pour les listes est une concaténation)
 Une liste Python ne stocke pas son contenu de façon efficace (i.e. contiguë) en
mémoire.

Le tableau : l’outil de base du calcul scientifique

Manipulation fréquente d’ensembles ordonnés discrets :
 Temps discrétisé d’une expérience/simulation.
 Signal enregistré par un appareil de mesure.
 Pixels d’une image, ...

Le module Numpy permet de :

 Créer d’un coup ces ensembles de données.
 Réaliser des opérations en “batch” sur les tableaux de données (pas de boucle sur
les éléments).
4
 Les tableaux

 Un tableau est une liste de nombres uniquement (flottants, entiers, complexes ….).

 Les tableaux peuvent être des vecteurs ou des matrices accessibles à partir de la librairie
Numpy qui doit être préalablement chargée et qui contient des fonctions permettant de
réaliser des calculs matriciels utilisés en algèbre linéaire. Le type tableau en python est
array.

 Un tableau est une structure référencée par un seul nom et qui est composée de
plusieurs données stockées de manière contiguë en mémoire (les unes à la suite des
autres).

 Au niveau de la mémoire, un tableau est donc une suite de cases (espace mémoire). La
taille de chacune des cases est conditionnée par le type de donnée que contient cette
case.

5
 Les tableaux : en algorithmique

 En algorithmique, la déclaration d’un tableau se fait de la façon suivante :

nom_tableau : tableau [« borne_inf » .. [« borne_sup» ] de type des

éléments
Ex : Notes :tableau [1 ..17] de réel

 Lecture d’un tableau:

Pour i de 1 à N faire
Ecrire(‘’donner l’élément n : ‘’,i)
Lire(Notes[i])
FinPour

 Ecriture d’un tableau (Affichage):

Pour i de 1 à N faire
Ecrire(Notes[i])
FinPour

6
Le tableau à une dimension: (unidimensionnel ou vecteur)

Fonctions Description
array(L) Crée un tableau à partir d'une liste L.

zeros(p) Crée un tableau de taille p rempli de zéros.

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

ndarray(p) Crée un tableau initialement rempli par p valeurs

réelles aléatoires

arange(a,b,k) Crée un vecteur par des valeurs commençant par a

jusqu’à b (exclu) avec un avancement de k.

linspace(a,b,n) Crée un vecteur de n valeurs régulièrement

espacées entre a et b (inclus).

7
 Le tableau à une dimension: (unidimensionnel ou vecteur)
Fonctions Exemples
Importer numpy import numpy as np
from numpy import * #autrement
Créer un tableau (taille >>> t=np.empty(3)
donnée, valeurs aléatoires) >>> type(t)
Créer un tableau à partir d’une >>> tab1 = np.array([10.2,3.4,3,4,5])
liste >>> type(tab1)
Taille du tableau >>> len(tab1)
Accès aux éléments du tableau >>> tab1[2]
tab [indice_deb : indice_fin] >>> tab1[1 :3] #éléments de 1 à 2
>>> tab1[0 :2] #éléments de 0 à 1
>>> tab1[ :3] #Les 3 premiers éléments
>>> tab1[3 :] #Tous sauf les 3 premiers
>>> tab1[-1]
>>> tab1[-2]
>>> arange(15) # correspond à la fonction
range() pour les listes

Tableaux particuliers >>> arange(15)

>>> arange(2,3,0.1)
>>> zeros(8) # Tableau avec un nombre de 0 spécifié
>>> ones(8) # Tableau avec un nombre de 1 spécifié
8
 Le tableau à une dimension: (unidimensionnel ou vecteur)
 Création via une saisie manuelle :
import numpy as np

a = np.array([1.2,2.5,3.2,1.8])

#type de la structure

print(type(a)) #<class ‘numpy.ndarray’>

#type des données

print(a.dtype) #float64

#nombre de dimensions

print(a.ndim) #1

print(np.ndim(a))

#nombre de lignes et de colonnes

print(a.shape) #(4,) on a un tuple ! 4 cases sur la 1ère dim

print(np.shape(a))

#nombre totale de valeurs

print(a.size) #4
9
print(np.size(a))
 Le tableau à une dimension: (unidimensionnel ou vecteur)
 Typage des données :

 Le typage des valeurs peut être implicite ou explicite

#création et typage implicite

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

print(a.dtype) #int32

#création et typage explicite

a = np.array([1,2,4],dtype=float)

print(a.dtype) #float64

print(a) #[1. 2. 4.]

10
Le tableau à une dimension: (unidimensionnel ou vecteur)

#un vecteur de booléens est tout à fait possible

b = np.array([True,False,True,True], dtype=bool)

print(b) #[True False True True]

 Création d’un array d’objets complexes (autres que les types de base)
est possible

# la donnée peut être un objet python

a = np.array([{"Toto":(45,2000)},{"Tata":(34,1500)}])

print(a.dtype) #object

print(a) #[{'Toto': (45, 2000)} {'Tata': (34, 1500)}]

11
 Le tableau à une dimension: (unidimensionnel ou vecteur)
 Création d’une séquence de valeurs:
#suite arithmétique de raison 1

a = np.arange(start=0,stop=10)

print(a) #[0 1 2 3 4 5 6 7 8 9] ,attention dernière valeur est exclue

#suite arithmétique de raison step

a = np.arange(start=0,stop=10,step=2)

print(a) #[0 2 4 6 8]

#suite linéaire, nb. de valeurs est spécifié par num

a = np.linspace(start=0,stop=10,num=5)

print(a) #[0. 2.5 5. 7.5 10.] ,la dernière valeur est incluse ici

#vecteur de valeurs identiques 1 – 1 seule dim et 5 valeurs

a = np.ones(shape=5)

print(a) # [1. 1. 1. 1. 1.]

12
 Le tableau à une dimension: (unidimensionnel ou vecteur)

 Redimensionnement:

 Rajouter une valeur en dernière position :

#vecteur de valeurs

a = np.array([1.2,2.5,3.2,1.8])

#ajouter une valeur , placée en dernière position

a = np.append(a,10)

print(a) #[1.2 2.5 3.2 1.8 10.]

 Suppression d’une valeur via son indice :

#suppression via indice

b = np.delete(a,2) #une plage d’indices est aussi possible

print(b) #[1.2 2.5 1.8 10.]

13
Le tableau à une dimension: (unidimensionnel ou vecteur)
 Redimensionnement explicite

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

#redimensionnement

#1 valeur pour vecteur

a.resize(5)

print(a) #[1 2 3 0 0] ,les nouvelles cases mises à 0

 Concaténation de 2 vecteurs

#concaténation 2 vecteurs

x = np.array([1,2,5,6])

y = np.array([2,1,7,4])

z = np.append(x,y)

print(z) #[1 2 5 6 2 1 7 4]
14
 Le tableau à une dimension: (unidimensionnel ou vecteur)
 Extraction des valeurs :

 Accès indicé – Plages d’indices – v = np.array([1.2,7.4,4.2,8.5,6.3])

#toutes les valeurs
print(v) #ou print(v[:])
#accès indicé - première valeur
print(v[0]) # 1.2
#dernière valeur
print(v[v.size-1]) # 6.3 ,v.size est utilisable car v est un vecteur
#plage d'indices contigus
print(v[1:3]) # [7.4 4.2]
#extrêmes, début à 3 (non-inclus)
print(v[:3]) # [1.2 7.4 4.2]
#extrêmes, 2 à fin
print(v[2:]) # [4.2 8.5 6.3]
#indice négatif
print(v[-1]) # 6.3 ,dernier élément
#indices négatifs
print(v[-3:]) # [4.2 8.5 6.3] ,3 derniers éléments 15
Le tableau à une dimension: (unidimensionnel ou vecteur)
 Accès par conditions– Indiçage booléen - v = np.array([1.2,7.4,4.2,8.5,6.3])
#extraction avec un vecteur de booléens
#si b trop court, tout le reste est considéré False
b = np.array([False,True,False,True,False],dtype=bool)
print(v[b]) # [7.4 8.5]

#on peut utiliser une condition pour l'extraction

print(v[v < 7]) # [1.2 4.2 6.3]

#parce que la condition est un vecteur de booléen

b=v<7
print(b) # [True False True False True]
print(type(b)) # <class ‘numpy.ndarray’>

#on peut utiliser la fonction extract()

print(np.extract(v < 7, v)) # [1.2 4.2 6.3]
16
Le tableau à une dimension: (unidimensionnel ou vecteur)
 Tri et recherche -- v = np.array([1.2,7.4,4.2,8.5,6.3])
#recherche valeur max et min
print(max(v))
print( v.max()) # 8.5
print(min(v))
print( v.min()) # 1.2
#recherche indice de valeur max et min
print(np.argmax(v)) #3
print(np.argmin(v)) #0
#tri des valeurs
print(np.sort(v)) # [1.2 4.2 6.3 7.4 8.5]
#récupération des indices triés
print(np.argsort(v)) # [0 2 4 1 3]
#valeurs distinctes
a = np.array([1,2,2,1,1,2])
print(np.unique(a)) # [1 2]
17
Le tableau à une dimension: (unidimensionnel ou vecteur)
 Calculs (statistiques) récapitulatifs -- v = np.array([1.2,7.4,4.2,8.5,6.3])

#moyenne

print(np.mean(v)) # 5.52

#médiane

print(np.median(v)) # 6.3

#variance
print(np.var(v)) # 6.6856

#quantile

print(np.percentile(v,50)) #6.3 (50% = médiane)

#somme
print(np.sum(v)) # 27.6

#somme cumulée

print(np.cumsum(v)) # [1.2 8.6 12.8 21.3 27.6] 18

 Le tableau à une dimension: (unidimensionnel ou vecteur)
 Calculs entre vecteurs : Les calculs se font élément par élément (elemenstwise) entre
les vecteurs « numpy » - On a le même principe sous R.
x = np.array([1.2,1.3,1.0])
y = np.array([2.1,0.8,1.3])
#opérations logiques
#multiplication
print(x*y) # [2.52 1.04 1.3] a=np.array([True,True,False,True],dtype=bool)
b=np.array([True,False,True,False],dtype=bool)
#addition
print(x+y) # [3.3 2.1 2.3]
#ET logique
#multiplication par un scalaire
print(2*x) # [2.4 2.6 2. ] np.logical_and(a,b) # [True False False False]

#comparaison de vecteurs #OU exclusif logique

x = np.array([1,2,5,6]) np.logical_xor(a,b) # [False True True True]
y = np.array([2,1,7,4])
b=x>y
print(b) # [False True False True] 19
 Le tableau à une dimension: (unidimensionnel ou vecteur)
 Fonctions matricielles : certaines fonctions matricielles s’appliquent à des
vecteurs
x = np.array([1.2,1.3,1.0])
y = np.array([2.1,0.8,1.3])

#produit scalaire
z = np.vdot(x,y)
print(z) # 4.86

#ou l’équivalent calculé

print(np.sum(x*y)) # 4.86

#norme d'un vecteur

n = np.linalg.norm(x)
print(n) # 2.03

#ou l’équivalent calculé

import math
print(math.sqrt(np.sum(x**2))) # 2.03
20
 Le tableau à une dimension: (unidimensionnel ou vecteur)
 Opérations ensemblistes : Un vecteur de valeurs (surtout entières) peut être
considéré comme un ensemble de valeurs.

#opérations ensemblistes
x = np.array([1,2,5,6])
y = np.array([2,1,7,4])

#intersection
print(np.intersect1d(x,y)) # [1 2]

#union – attention, ce n’est pas une concaténation

print(np.union1d(x,y)) # [1 2 4 5 6 7]

#différence c.à-d. qui sont dans x et pas dans y

print(np.setdiff1d(x,y)) # [5 6]
21