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 matrices
Dr. Ghabri Afef Année Universitaire : 2020-2021
 Introduction

 Numpy est un package pour Python spécialisé dans la manipulation des

tableaux (array), pour nous essentiellement les vecteurs et les matrices.

 Les tableaux «numpy» ne gère que les objets de même type.

 Le package propose un grand nombre de routines pour un accès rapide aux

données (ex. recherche, extraction), pour les manipulations diverses (ex. tri),

pour les calculs (ex. calcul statistique).

 Les tableaux «numpy» sont sous-jacents à de nombreux packages dédiés au

calcul scientifique sous Python.

 Une matrice est un tableau (array) à 2 dimensions.

1
Le tableau à deux dimensions: (bidimensionnel ou matrice)
Fonctions Description
ndarray((p,q)) Crée une matrice de p lignes et q colonnes
initialement remplie par des valeurs réelles
aléatoires.
zeros((p,q)) Crée une matrice de p lignes et q colonnes remplie
par des valeurs nulles.
ones((p,q)) Crée une matrice de p lignes et q colonnes remplie
par des valeurs égales à 1.
diag(L) Crée une matrice diagonale. L représente la liste
des éléments de la diagonale.
identity(p) Crée une matrice identité de l’ordre p
reshape(T,p) ou Redimensionnement d’un tableau sans modifier son
reshape(T,(p,q)) nombre d’éléments
dot(M, N) Effectue un produit matriciel de 2 matrices
rank(T) Rang d’un tableau
copy(T) Copie d’un tableau T (T.copy() est aussi utilisable)
eye(n) matrice de taille n avec des 1 sur la diagonale et
des zéros ailleurs 2
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
Fonctions Exemples
Créer un tableau à 2 D >>> tab2D1 = array([[1, 2, 3],[4, 5, 6]])
>>> tab2D1
>>> type(tab2D1)

Dimensions du tableau >>> shape(tab2D1)

Nombres d’éléments >>> size(tab2D1)

Taille du tableau >>> len(tab2D1)

Accès aux éléments du >>> tab2D1[1][2]
tableau >>> tab2D1[0,:] #première ligne
tab [indice_deb : indice_fin] >>> tab2D1[:,0] #première colonne

ajoute une ligne ou une >>> t = array([[10,15,20]])

colonne avec la fonction >>> t=append(t,[[1,2,3]],axis=0) #ligne : axis = 0
append >>> t=append(t,[[4],[5]],axis=1) #colonne : axis = 1
Tableaux particuliers >>> zeros((6,2)) # Tableau avec un nombre de 0 spécifié
>>> ones((2,2)) # Tableau avec un nombre de 1 spécifié

3
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Création d’une matrice via une saisie manuelle :
o importer le module « numpy » : np sera l’alias utilisé pour accéder aux routines
de la librairie « numpy ».

import numpy as np

o Création manuelle à partir d’un ensemble de valeurs

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

#type de la structure
print(type(a)) #<class ‘numpy.ndarray’>
#type des données
print(a.dtype) #float64
#nombre de dimensions
print(a.ndim) #2 (car c’est une matrice)
#nombre de lignes et col, shape renvoie un tuple
print(a.shape) #(3,2)  3 lignes et 2 colonnes
#nombre totale de valeurs
print(a.size) #6, nb.lignes x nb.colonnes 4
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Typage des données :

 Affichage d’une matrice dans la console (IPython)

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

 Le typage des valeurs peut être implicite ou explicite

#création et typage implicite
a = np.array([[1,2],[4,7]])
print(a.dtype) #int32
#création et typage explicite – préférable !
a = np.array([[1,2],[4,7]],dtype=float)
print(a.dtype) #float64

 Tout comme pour les vecteurs, la création d’une matrice d’objets

complexes (autres que les types de base) est possible.
5
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Création d’une matrice à partir d’une séquence de valeurs :
#création à partir d'une séquence : arange() génère une séquence de valeurs, 0 à 9.
#attention les dim. doivent être compatibles
a = np.arange(0,10).reshape(2,5) #réorganiser en matrice 2 lignes et 5 colonnes
a.flatten() ?
print(a)

#un vecteur peut être converti en matrice

a = np.array([2.1,3.4,6.7,8.1,3.5,7.2])
print(a.shape) # (6,)
#redim. en 3 lignes x 2 col.
b = a.reshape(3,2)
print(b.shape) # (3, 2)
print(b)

#matrices de valeurs identiques

#ex. pour une initialisation
a = np.zeros(shape=(2,4))
print(a) 6
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Il est possible de transformer un array bidimensionnel en un array unidimensionnel avec
reshape ou flatten. L’instruction b.flatten() renvoie une copie de b, ce qui n’est pas le
cas de reshape. Ici un exemple avec la syntaxe np.reshape(array,dimension).

b=np.ones((4,4),float)+np.eye(4,4)

print (b)

[[ 2. 1. 1. 1.]

[ 1. 2. 1. 1.]

[ 1. 1. 2. 1.]

[ 1. 1. 1. 2.]]

np.reshape(b,16) #array([ 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 2.])

np.reshape(b,(2,8))

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

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

b.flatten() #array([ 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 2.]) 7
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Numpy permet d’assembler les vecteurs et les matrices, de les concaténer. Par défaut
l’assemblage se fait selon la 1ère dimension (les lignes, donc assemblage vertical).
L’option axis=1 assemble “horizontalement”.

>>> a=np.arange(4).reshape(2,2)
>>> b=4+np.arange(4).reshape(2,2)
>>> b
array([[4, 5],
[6, 7]])
>>> np.concatenate((a,b)) # np.concatenate((a,b),axis=0)
array([[0, 1],
[2, 3],
[4, 5],
[6, 7]])
>>> np.concatenate((a,b),axis=1)
array([[0, 1, 4, 5],
[2, 3, 6, 7]])
8
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Redimensionnement
a=
Accoler le vecteur b en tant
que nouvelle ligne (axis = 0)
de la matrice a
Accoler le vecteur d en tant
que nouvelle colonne (axis =
1) de la matrice a
Insertion de b en tant que
nouvelle ligne (axis = 0) à la
position n°1
Suppression de la ligne (axis
= 0) via son indice (n°1)
Redimensionnement d’une
matrice
#matrice de valeurs
a = np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]])
#ajouter une ligne –concaténation
b = np.array([[4.1,2.6]])
c = np.append(a,b,axis=0)
print(c)
#ajouter une colonne
d = np.array([[7.8],[6.1],[5.4]])
print(np.append(a,d,axis=1))
#insertion
print(np.insert(a,1,b,axis=0))
#suppression
print(np.delete(a,1,axis=0))
#modifier la dimension d'une matrice existante
#parcourt les données ligne par ligne
h = np.resize(a,new_shape=(2,3))
print(h)
z=a.resize((2,3)) #type(z)? 9
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Extraction des valeurs :
• Accès indicé – Plages d’indices – v = np.array([[1.2,2.5],[3.2,1.8],[1.1,4.3]])
#affichage de la structure dans son ensemble
print(v)
#accès indicé - première valeur
print(v[0,0]) # 1.2
#dernière valeur – noter l’utilisation de shape (qui est un tuple)
print(v[v.shape[0]-1,v.shape[1]-1]) # 4.3
#autre solution pour l’affichage de toutes les valeurs, noter le rôle des :
print(v[:,:])
#plage d'indices contigus : lignes 0 à 1 (2 non inclus), toutes les colonnes
print(v[0:2,:])
#extrêmes, début to 2 (non-inclus)
print(v[:2,:])
#extrêmes, lignes 1 à dernière
print(v[1:,:])
#indice négatif – dernière ligne et toutes les colonnes
print(v[-1,:])
#indices négatifs – deux dernières lignes et toutes les colonnes
print(v[-2:,:]) 10
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Le “slicing” permet d’extraire des éléments d’un vecteur ou matrice. Il existe aussi la commande
np.take qui extrait lignes/colonnes d’un array. L’option axis détermine une extraction selon les
lignes/colonnes. La syntaxe se comprend aisément.

>>> a=np.arange(16).reshape(4,4) La réciproque de np.take est np.put

>>> a.take([0,3],axis=1)
>>> a=np.array([0, 1, 2, 3, 4, 5],float)
array([[ 0, 3], >>> b=np.array([9,8,7],float)
[ 4, 7], >>> a.put([0,3],b)
[ 8, 11], >>> a
[12, 15]]) array([ 9., 1., 2., 8., 4., 5.])
>>> a.take([0,3])
Comme deux positions seulement ont
array([0, 3]) été données, seules la valeurs 0 et 3 ont
>>> a.take([0,3],axis=0) été remplacées.
array([[ 0, 1, 2, 3],
[12, 13, 14, 15]])
>>> a.take([0,3,2,2,2],axis=0)
array([[ 0, 1, 2, 3],
[12, 13, 14, 15],
[ 8, 9, 10, 11],
[ 8, 9, 10, 11],
11
[ 8, 9, 10, 11]])
Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Accès par conditions– Indiçage booléen - v =
#indiçage par vecteur de booléens
#si b trop court, tout le reste est considéré False
b = np.array([True,False,True],dtype=bool)
print(v[b,:])

#exemple illustratif : extraire la lignes dont la somme est la plus petite

#calculer la somme des colonnes pour chaque ligne

s = np.sum(v,axis=1)
print(s) # [ 3.7 5. 5.4 ]

#repérer les lignes dont la somme est égale au minimum

#il est possible qu’il y en ait plusieurs
b = (s == np.min(s))
print(b) # [ True False False]

#application du filtre booléen

12
print(v[b,:])
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Tri et recherche -- v =

#recherche valeur max des lignes (axis = 0) pour chaque colonne

print(np.max(v,axis=0)) # [ 3.2 4.3 ] -- décryptage : 3.2 est la max des lignes pour
la colonne 0, 4.3 est la max des lignes pour la colonne 1
#recherche valeur max des colonnes (axis = 1) pour chaque ligne

print(np.max(v,axis=1)) # [ 2.5 3.2 4.3] # np.amax(v,axis=1)

#recherche indice de valeur max des lignes (axis = 0)pour chaque colonne

print(np.argmax(v,axis=0)) #[1 2]

#tri des lignes (axis = 0) pour chaque colonne

#la relation entre les valeurs d'une même ligne est perdue !!!

print(np.sort(v,axis=0))

#récupération des indices triés

print(np.argsort(v,axis=0))
13
 Stratégies pour parcourir une matrice
 Parcours d’une matrice : boucles indicées -- v=

Avec les indices, nous pouvons accéder aux valeurs de la matrice (ligne par
ligne ou colonne par colonne).

#boucles indicées

s = 0.0

for i in range(0,v.shape[0]):

for j in range(0,v.shape[1]):

print(v[i,j])

s = s + v[i,j]

print("Somme = ",s)

14
 Stratégies pour parcourir une matrice
 Parcours d’une matrice : les itérateurs -- v=

Avec les itérateurs, nous pouvons accéder aux valeurs de la matrice sans
avoir à recourir aux indices (ligne par ligne, colonne par colonne)
#itérateur - accès ligne par ligne
s = 0.0
for x in np.nditer(v):
print(x)
s=s+x
print("Somme = ",s)

#itérateur - accès colonne par colonne

#"F" pour " Fortran order "
s = 0.0
for x in np.nditer(v,order="F"):
print(x)
s = s +x
print("Somme = ",s) 15
 Calcul sur les matrices
 Calculs statistiques: les calculs sont réalisés selon un axe (0 : traitement des valeurs
en ligne pour chaque colonne, 1 : inversement) --- v=

#moyenne des lignes pour chaque colonne

print(np.mean(v,axis=0)) # [1.833 2.867]

#moyenne des colonnes pour chaque ligne

print(np.mean(v,axis=1)) # [1.85 2.5 2.7]

#somme cumulée des valeurs en ligne pour chaque colonne

print(np.cumsum(v,axis=0))

#matrice de corrélation

#rowvar = 0 pour indiquer que les variables sont organisés en colonnes

m = np.corrcoef(v,rowvar=0)

print(m)
16
 Calcul sur les matrices
 Fonctions matricielles et algèbre linéaire:
x= y=

#transposition
print(np.transpose(x))
#multiplication
print(np.dot(x,y))
#déterminant
print(np.linalg.det(y)) # 4.21
#inversion
print(np.linalg.inv(y))
#résolution d'équation Y.a = z
z = np.array([1.7,1.0])
print(np.linalg.solve(y,z)) # [0.8195 -0.0261]
#vérification / On peut faire a = Y-1.z
print(np.dot(np.linalg.inv(y),z)) # [0.8195 -0.0261]
#matrice symétrique avec XTX
s = np.dot(np.transpose(x),x)
print(s)
#val. et vec. propres d'une matrice symétrique
print(np.linalg.eigh(s))
17
 Calcul sur les matrices
print(np.linalg.eig(s))
#les valeurs propres de la matrice s
print(np.linalg.eigvals(s))

 Opérations arithmétiques sur les termes d’un tableau:

T*a Multiplication des termes du tableau T par le

scalaire a

T+a Addition de a aux éléments de T

T/a Division des éléments de T par a

T**a Exponentiation: puissance aième des éléments

de T
T*T Multiplication terme à terme des éléments du
tableau
T+T Addition terme à terme des éléments du tableau

18
 Sous-module random de numpy
Le sous-module random de numpy permet d'obtenir des nombres aléatoires,
random.rand pour générer des nombres aléatoires de loi uniforme U(0,1), random.randn
pour la loi normale centrée réduite (N(0,1)) et random.randint pour une loi uniforme sur un
intervalle d'entiers.

>>> from numpy import *

>>> random.rand(4) # pour un tableau 1d à 4 éléments
array([ 0.90538856, 0.23389902, 0.17182099, 0.81463087])

>>> random.randn(3,3) # pour un tableau 2d 3 x 3

array([[-0.15114084, 0.09718998, -0.81857774],
[-0.05252272, 0.02244689, 1.01026781],
[ 0.45428138, 0.64223423, 0.58867134]])

>>> random.randint(0,9,80) # loi uniforme sur les entiers de [0,9[ (donc [0,8])
array([4, 2, 5, 4, 5, 2, 8, 8, 1, 7, 0, 1, 1, 5, 3, 7, 5, 2, 3, 2, 6, 5, 3, 2, 1, 2, 6, 8, 0, 1, 4,
5, 0, 2, 6, 7, 5, 6, 6, 3, 5, 5, 6, 8, 0, 4, 2, 6, 4, 3, 8, 2, 2, 8, 3, 8, 8, 3, 5, 2, 0, 4, 2, 6, 2,
6, 4, 4, 5, 3, 1, 0, 5, 7, 3, 4, 4, 0, 2, 8])

>>> random.randint(0,9,(3,3)) # pour obtenir une matrice 3 x 3

array([[3, 6, 8],
[6, 4, 0],
[5, 3, 4]]) 19
 Autres commandes et fonctions
Commande Bibliothèque Résultat
rint(x) numpy Nombre entier le plus proche de x
floor(x) numpy Partie entière inférieure de x
ceil(x) numpy Partie entière supérieure de x

sqrt(x) numpy Racine carrée de x

exp(x), log(x) numpy Exponentielle, logarithme népérien

sin(x), cos(x) numpy Fonctions sinus et cosinus
arcsin(x), arccos(x) numpy Fonctions trigonométriques inverses
rand() numpy.random Générateur aléatoire sur [0,1]
rand(n,p) numpy.random Générateur aléatoire de matrice de
dimension n*p sur [0,1]
pi numpy Valeur approchée ~ 3.1415
exp(1) numpy Valeur approchée de e ~2.7183
20
 Autres commandes et fonctions
Commande Bibliothèque Résultat
matrix([a, b, ..]) numpy Représente le vecteur horizontal
[a b ….. d]
matrix([[a], [b], numpy Représente le vecteur vertical
..])
matrix([[a,b .. d], numpy Représente la matrice
[e,f ..,h], ..])
zeros([n,p]) numpy Représente la matrice nulle de taille n*p
ones([n,p]) numpy Représente la matrice de coefficients 1
de taille n*p
eye(n,p) numpy Représente la matrice identité de taille
n*p
asarray(m) numpy Transforme une matrice en tableau

asmatrix(m) numpy Transforme un tableau en matrice

norm(m) numpy.linalg Norme de la matrice m
21
 Autres commandes et fonctions

Commande Bibliothèque Résultat

poly1d([a .. d]) numpy Représente le polynôme axn+….cx+d

poly1d([a .. numpy Représente le polynôme (x-a)…..(x-d)

d],True)
p.order numpy Degré du polynôme p

p.roots, numpy Racines du polynôme p

roots(p)

p.coeffs numpy Coefficients du polynôme p

p(x), numpy Évalue le polynôme au point (selon le

polyval(p,x) schéma de Horner)

22