La bibliothèque $\mathtt{NumPy}$

Retour au tutoriel général

La documentation complète est disponible à l'adresse https://numpy.org/doc/stable/

• La bibliothèque $\mathtt{NumPy}$ contient aussi les principales constantes et fonctions mathématiques ainsi qu'un générateur pseudo-aléatoire.

import numpy as np

print("Les outils classiques")
print(np.pi)
print(np.sin(np.pi/3))


print('\n')
print("Un peu d'aléatoire")
from numpy import random
print(random.rand())
print(random.randint(1,25))

random.seed(1)
print(random.rand())

random.seed(1)
print(random.rand())

Les outils classiques
3.141592653589793
0.8660254037844386


Un peu d'aléatoire
0.28119257913784734
15
0.417022004702574
0.417022004702574

Le type $\mathtt{array}$ de $\mathtt{NumPy}$

• Mais elle permet de faire beaucoup plus de choses... Elle est notamment adaptée pour gérer les matrices et les vecteurs.

Ici il convient de bien réfléchir à ce dont on a besoin. Si l'on a simplement besoin d'une structure matricielle alors une liste de listes est probablement suffisante. Si l'on a besoin des outils de l'algèbre linéaire (produit matrice vecteur, produit matrice matrice...) il est inenvisageable de les recoder. Pour cela la bibliothèque $\mathtt{NumPy}$ comprend un nouveau type : $\mathtt{array}$. Ce sont des tableaux dont le fonctionnement est très proche de celui du type $\mathtt{list}$.

import numpy as np
a=np.array([0,1,2,3,4])
print(a)

print(a[2])
a[2]=5

print("le tableau modifié : ", a)

print("une partie du tableau : ", a[2:])

[0 1 2 3 4]
2
le tableau modifié :  [0 1 5 3 4]
une partie du tableau :  [5 3 4]

• Un $\mathtt{array}$ peut contenir des données de n'importe quel type. Mais attention toutes les données au sein d'un tel tableau doivent être du même type. Regardez les "conversions" automatiques dans les deux exemples ci-dessous.

import numpy as np
a=np.array([0,1,2,3])
print(a)
a[2]=2.5
print(a)

[0 1 2 3]
[0 1 2 3]

import numpy as np
a=np.array(['t','e','s','t'])
print(a)
a[2]=2
print(a)

['t' 'e' 's' 't']
['t' 'e' '2' 't']

Le type du tableau est le type utilisé lors de son initialisation. Si besoin, on peut le spécifier directement. C'est notamment le cas d'un tableau initialisé avec des entiers destiné à pouvoir contenir des $\mathtt{float}$.

import numpy as np
a=np.array([0,1,2,3],dtype=np.float64)
print(a)
a[2]=2.5
print(a)

[0. 1. 2. 3.]
[0.  1.  2.5 3. ]

• Les constructeurs. Il existe un certain nombre de constructeurs pour initialiser un tableau de taille donnée.

import numpy as np

print("Illustation de différents constructeurs")

print("Un tableau rempli de 0 : ", np.zeros(4))

print("Un tableau rempli de 1 : ", np.ones(4))

print("l'équivalent de range : ", np.arange(4))

Illustation de différents constructeurs
Un tableau rempli de 0 :  [0. 0. 0. 0.]
Un tableau rempli de 1 :  [1. 1. 1. 1.]
l'équivalent de range :  [0 1 2 3]

Notez que le type par défaut des commandes $\mathtt{zeros}$ et $\mathtt{ones}$ est $\mathtt{float}$ alors que pour $\mathtt{arange}$ c'est $\mathtt{int}$.

Il existe une autre commande $\mathtt{linspace}(a,b,n)$ qui fournit le tableau de $a$ à $b$ (inclus) avec $n$ points équirépartis.

import numpy as np
print(np.linspace(0,2,11))

[0.  0.2 0.4 0.6 0.8 1.  1.2 1.4 1.6 1.8 2. ]

• Il existe un grand nombre de fonctions et méthodes implémentés pour les $\mathtt{array}$. Quelques exemples ci-dessous.

import numpy as np
a = np.array([0,1,3,4])

print(a.min())  # minimum
print(a.max())  # maximum
print(a.sum())  # somme
print(a.mean()) # moyenne

0
4
8
2.0

Une autre différence importante entre $\mathtt{array}$ et $\mathtt{list}$ est la surcharge des opérateurs. Le type $\mathtt{array}$ représente des vecteurs. Ainsi l'opérateur $+$ effectue l'addition terme à terme (et non la concaténation comme pour les listes). Il est bien sûr nécessaire que les deux tableaux aient la même taille. La plupart des opérations sont effectuées terme à terme.

import numpy as np
a = np.array([0,1,2])
b = np.array([1,1,1])

print(a+b)
print(a-b)
print(3*a)
print(a==0)

[1 2 3]
[-1  0  1]
[0 3 6]
[ True False False]

L'opérateur $*$ effectue la multiplication terme à terme.

import numpy as np
a = np.array([0,1,2])
b = np.array([1,2,3])

print(a*b)

[0 2 6]

La concaténation s'obtient par la fonction $\mathtt{concatenate}$.

import numpy as np
a = np.array([0,1,2])
b = np.array([1,1,1])

np.concatenate((a,b))  # attention aux doubles parenthèses

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

La longueur s'obtient avec la fonction $\mathtt{size}$

import numpy as np
a = np.array([0,1,2,3])
print(np.size(a))

4

Algèbre linéaire : vecteurs et matrices

• Les matrices sont dès lors définies comme des $\mathtt{array}$ d'$\mathtt{array}$. Elles sont définies ligne par ligne.

import numpy as np
M = np.array([[0,1,2],[3,4,5]])
print(M)

print("Elément 2eme ligne, 1ere colonne = ", M[1][0])
print("Elément 2eme ligne, 1ere colonne = ", M[1,0])  # autre syntaxe

M[1][0] = 6
print(M)

[[0 1 2]
 [3 4 5]]
Elément 2eme ligne, 1ere colonne =  3
Elément 2eme ligne, 1ere colonne =  3
[[0 1 2]
 [6 4 5]]

Le nombre de lignes et de colonnes (et donc la taille d'un vecteur) sont obtenues par l'attribut $\mathtt{shape}$.

import numpy as np
M = np.array([[0,1,2],[3,4,5]])

print(M.shape)

v = np.array([1,2,3])
print(v.shape)

(2, 3)
(3,)

• On peut modifier la forme d'une matrice en utilisant la méthode $\mathtt{reshape}$.

import numpy as np
v = np.arange(6)
print("c'est un vecteur : ", v)

M = v.reshape(3,2)
print("c'est maintenant une matrice 3 lignes 2 colonnes \n", M)

M2 = M.reshape(2,3)
print("ou 2 lignes 3 colonnes \n", M2)

v2 = M2.reshape(6,)
print("et on en refait un vecteur : ", v2)

c'est un vecteur :  [0 1 2 3 4 5]
c'est maintenant une matrice 3 lignes 2 colonnes 
 [[0 1]
 [2 3]
 [4 5]]
ou 2 lignes 3 colonnes 
 [[0 1 2]
 [3 4 5]]
et on en refait un vecteur :  [0 1 2 3 4 5]

On peut aussi facilement insérer de nouvelles lignes ou colonnes dans une matrice existante avec la fonction $\mathtt{insert}$. Ainsi, $\mathtt{np.insert(M, j, values=c, axis=1)}$ insère la colonne $c$ dans la matrice $M$ avant la colonne $j$. Le paramètre $\mathtt{axis=1}$ indique que ce sont des colonnes (pour les lignes il faut indiquer $\mathtt{axis=0}$).

import numpy as np

M = np.array([[0, 1], [2,3]])
print(M)
print(M.shape, '\n')

print("On ajoute une colonne en dernière position")
c = np.array([12,13])
M2 = np.insert(M, 2, values=c, axis=1) # axis = 1 pour insérer une colonne
print(M2)
print(M2.shape)

print("On ajoute une ligne en première position")
l = np.array([-3,-2,-1])
M3 = np.insert(M2, 0, values=l, axis=0) # axis = 0 pour insérer une ligne
print(M3)
print(M3.shape)

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

On ajoute une colonne en dernière position
[[ 0  1 12]
 [ 2  3 13]]
(2, 3)
On ajoute une ligne en première position
[[-3 -2 -1]
 [ 0  1 12]
 [ 2  3 13]]
(3, 3)

L'extraction de sous-matrices est obtenue en prenant des tranches, comme pour les listes.

import numpy as np

M = np.arange(9)
M = np.reshape(M, newshape=(3,3))
print(M)

# on garde la sous-matrice des deux premières lignes et colonnes.
M2 = M[0:2,0:2]
print("Une sous-matrice : ",'\n', M2)

# on garde la sous-matrice correspondant à enlever la colonne du milieu
M3 = M[:,[0,2]]
print("Une autre sous-matrice : ",'\n', M3)

[[0 1 2]
 [3 4 5]
 [6 7 8]]
Une sous-matrice :  
 [[0 1]
 [3 4]]
Une autre sous-matrice :  
 [[0 2]
 [3 5]
 [6 8]]

• Le produit matrice vecteur ou matrice matrice est implémenté avec la méthode $\mathtt{dot}$.

import numpy as np
M = np.array([[0,1,2],[3,4,5]])
v = np.array([1,1,1])

p = M.dot(v)
print(p)

[ 3 12]

Attention dans la bibliothèque $\mathtt{NumPy}$ il n'y a pas de différence entre vecteur ligne et vecteur colonne.

import numpy as np
M = np.array([[1,2,3],[4,5,6],[7,8,9]])
v = np.array([1,1,1])

print(M.dot(v))
print(v.dot(M))

[ 6 15 24]
[12 15 18]

• La sous-bibliothèque $\mathtt{linalg}$ fournit un certain nombre de fonctions pour l'algèbre linéaire.

La fonction $\texttt{matrix}\_\texttt{power}$ permet de calculer des puissances de matrices.

import numpy as np
from numpy.linalg import matrix_power

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

print("M² =",matrix_power(M,2))

M² = [[ 30  36  42]
 [ 66  81  96]
 [102 126 150]]

On y trouvera aussi par exemple des fonctions pour calculer le déterminant, les valeurs et vecteurs propres...

La fonction $\mathtt{solve}$ permet de résoudre numériquement le système linéaire $AX = b$.

import numpy as np

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

X = np.linalg.solve(A,b)
print(X)

print("On vérifie AX - b = ", A.dot(X)-b)

[ 0.2 -1.4  1.2]
On vérifie AX - b =  [ 0.0000000e+00 -8.8817842e-16  0.0000000e+00]