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
 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.

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 ([Link]() est aussi utilisable)

eye(n) matrice de taille n avec des 1 sur la diagonale et

des zéros ailleurs
 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)

Nombre de lignes >>> 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é
 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 = [Link]([[1.2,2.5],[3.2,1.8],[1.1,4.3]])

#type de la structure
print(type(a)) #<class ‘[Link]’>
#type des données
print([Link]) #float64
#nombre de dimensions
print([Link]) #2 (car c’est une matrice)
#nombre de lignes et col, shape renvoie un tuple
print([Link]) #(3,2)  3 lignes et 2 colonnes
#nombre totale de valeurs
print([Link]) #6, [Link] x [Link]
 Le tableau à deux dimensions: (bidimensionnel ou matrice)

 Typage des données :

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

a = [Link]([[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 = [Link]([[1,2],[4,7]])
print([Link]) #int32
#création et typage explicite – préférable !
a = [Link]([[1,2],[4,7]],dtype=float)
print([Link]) #float64

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

complexes (autres que les types de base) est possible.
 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 = [Link](0,10).reshape(2,5) #réorganiser en matrice 2 lignes et 5 colonnes
[Link]() ?
print(a)

#un vecteur peut être converti en matrice

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

#matrices de valeurs identiques

#ex. pour une initialisation
a = [Link](shape=(2,4))
print(a)
 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 [Link]() renvoie une copie de b, ce qui n’est pas le
cas de reshape. Ici un exemple avec la syntaxe [Link](array,dimension).

b=[Link]((4,4),float)+[Link](4,4)

print (b)

[[ 2. 1. 1. 1.]

[ 1. 2. 1. 1.]

[ 1. 1. 2. 1.]

[ 1. 1. 1. 2.]]

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

[Link](b,(2,8))

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

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

[Link]() #array([ 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 2.])
 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=[Link](4).reshape(2,2)
>>> b=4+[Link](4).reshape(2,2)
>>> b
array([[4, 5],
[6, 7]])
>>> [Link]((a,b)) # [Link]((a,b),axis=0)
array([[0, 1],
[2, 3],
[4, 5],
[6, 7]])
>>> [Link]((a,b),axis=1)
array([[0, 1, 4, 5],
[2, 3, 6, 7]])
 Le tableau à deux dimensions: (bidimensionnel ou matrice)

 Redimensionnement
#matrice de valeurs
a= a = [Link]([[1.2,2.5],[3.2,1.8],[1.1,4.3]])
Accoler le vecteur b en tant #ajouter une ligne –concaténation
que nouvelle ligne (axis = 0) b = [Link]([[4.1,2.6]])
de la matrice a c = [Link](a,b,axis=0)
print(c)

Accoler le vecteur d en tant #ajouter une colonne

que nouvelle colonne (axis = d = [Link]([[7.8],[6.1],[5.4]])
1) de la matrice a print([Link](a,d,axis=1))
Insertion de b en tant que #insertion
nouvelle ligne (axis = 0) à la print([Link](a,1,b,axis=0))
position n°1
Suppression de la ligne (axis #suppression
= 0) via son indice (n°1) print([Link](a,1,axis=0))
Redimensionnement d’une #modifier la dimension d'une matrice existante
matrice #parcourt les données ligne par ligne
h = [Link](a,new_shape=(2,3))
print(h)
z=[Link]((2,3)) #type(z)?
 Le tableau à deux dimensions: (bidimensionnel ou matrice)
 Extraction des valeurs :
• Accès indicé – Plages d’indices – v = [Link]([[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[[Link][0]-1,[Link][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:,:])
 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
[Link] 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=[Link](16).reshape(4,4) La réciproque de [Link] est [Link]

>>> [Link]([0,3],axis=1)
>>> a=[Link]([0, 1, 2, 3, 4, 5],float)
array([[ 0, 3], >>> b=[Link]([9,8,7],float)
[ 4, 7], >>> [Link]([0,3],b)
[ 8, 11], >>> a
[12, 15]]) array([ 9., 1., 2., 8., 4., 5.])
>>> [Link]([0,3])
Comme deux positions seulement ont
array([0, 3]) été données, seules la valeurs 0 et 3 ont
>>> [Link]([0,3],axis=0) été remplacées.
array([[ 0, 1, 2, 3],
[12, 13, 14, 15]])
>>> [Link]([0,3,2,2,2],axis=0)
array([[ 0, 1, 2, 3],
[12, 13, 14, 15],
[ 8, 9, 10, 11],
[ 8, 9, 10, 11],
[ 8, 9, 10, 11]])
Le tableau à deux dimensions: (bidimensionnel ou matrice)

v=

#calculer la somme des colonnes pour chaque ligne

s = [Link](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 == [Link](s))
print(b) # [ True False False]

#application du filtre booléen

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([Link](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([Link](v,axis=1)) # [ 2.5 3.2 4.3] # [Link](v,axis=1)

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

print([Link](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([Link](v,axis=0))

#récupération des indices triés

print([Link](v,axis=0))
 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,[Link][0]):

for j in range(0,[Link][1]):
print(v[i,j])

s = s + v[i,j]

print("Somme = ",s)
 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
for x in [Link](v):
print(x)
s=s+x
print("Somme = ",s)

#itérateur - accès colonne par colonne

#"F" pour " Fortran order "
s=0
for x in [Link](v,order="F"):
print(x)
s = s +x
print("Somme = ",s)
 Sous-module random de numpy
Le sous-module random de numpy permet d'obtenir des nombres aléatoires,
[Link] pour générer des nombres aléatoires de loi uniforme U(0,1), [Link]
pour la loi normale centrée réduite (N(0,1)) et [Link] pour une loi uniforme sur un
intervalle d'entiers.

>>> from numpy import *

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

>>> [Link](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]])

>>> [Link](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])

>>> [Link](0,9,(3,3)) # pour obtenir une matrice 3 x 3

array([[3, 6, 8],
[6, 4, 0],
[5, 3, 4]])
 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)
[Link] numpy Degré du polynôme p

[Link], numpy Racines du polynôme p

roots(p)

[Link] numpy Coefficients du polynôme p

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

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