Atelier Python-Numpy

1. Programmation Python
Calcul Scientifique avec Python
Numpy est une bibliothèque numérique apportant le support efficace de larges tableaux
multidimensionnels, et de routines mathématiques de haut niveau (fonctions spéciales,
algèbre linéaire, statistiques, etc.).
Numpy ou Scipy ?
Idéalement, NumPy ne devrait contenir que la classe array, avec les méthodes
permettant de réaliser des opérations de base sur ces arrays tandis que SciPy
contiendrait toutes les fonctions numériques qui utilisent ces arrays. De plus, SciPy
contient entièrement NumPy.
Lequel dois-on utiliser ?
 NumPy, si vous souhaitez simplement utiliser les arrays
 SciPy, pour les méthodes les plus avancées
Importer le module
Habituellement on importe NumPy avec un alias pour faciliter son utilisation.
>>> import numpy as np
Créer un array
# à partir d'une liste :
>>> a = np.array([1, 2, 3])
>>> a
array([1, 2, 3])
# avec la fonction arange
>>> r = np.arange(2, 10)
>>> r
array([2, 3, 4, 5, 6, 7, 8, 9])
>>> r = np.arange(2, 10, dtype="float64")
>>> r
array([ 2., 3., 4., 5., 6., 7., 8., 9.])
# avec des méthodes de numpy
>>> b = np.ones(4)
>>> b
array([ 1., 1., 1., 1.])
>>> x = np.zeros(3)
>>> x
array([ 0., 0., 0.])
#numpy.linspace(): répartition uniforme d’un nombre fixe de points entre un
#start et un end
>>> x = np.linspace(0, 2, 5)

2. >>> x
array([ 0. , 0.5, 1. , 1.5, 2. ])
>>> y = np.linspace(0, 1, 3)
>>> y
array([ 0. , 0.5, 1. ])
Type de données
Contrairement aux listes, les arrays contiennent un seul type de données :
>>> a.dtype
dtype('int64')
>>> b.dtype
dtype('float64')
Pour connaître le type du résultat de numpy.array(), on peut utiliser la fonction type().
>>> type(a)
numpy.ndarray
On constate que ce type est issu du package numpy. Ce type est différent de celui d’une liste.
>>> type([4, 7, 9])
list
Tableaux bidimensionnels (2D)
Pour créer un tableau 2D:
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> a
array([[1, 2, 3],
[4, 5, 6]])
zeros((m,n)) : renvoie un tableau 2D de taille m x n contenant des zéros
>>> np.zeros((2,3))
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
ones((m,n)) : renvoie un tableau 2D de taille m x n contenant des uns
>>> np.ones((2,3))
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
eye(n) : renvoie une matrice identité de taille n x n,
>>> np.eye(3)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
full((n,m),a): crée un tableau de taille n x m rempli d’une valeur fixe a
>>> x=np.full((2,4),5) #Tableau de dimensions 2x4 rempli de 5
>>> x
array([[5, 5, 5, 5],

3. [5, 5, 5, 5]])
La fonction numpy.size()
La fonction numpy.size() renvoie le nombre d’éléments du tableau.
>>> a = np.array([2,5,6,8])
>>> np.size(a)
4
>>> b = np.array([[1, 2, 3],
[4, 5, 6]])
>>> b.size
6
La fonction numpy.shape()
La fonction numpy.shape() (forme, en anglais) renvoie la taille du tableau.
>>> a = np.array([2,5,6,8])
>>> np.shape(a) # ou bien a.shape
(4,)
>>> b = np.array([[1, 2, 3],
[4, 5, 6]])
>>> np.shape(b) #b.shape
(2, 3)
On distingue bien ici que a et b correspondent à des tableaux 1D et 2D, respectivement.
La fonction numpy.ndim()
La fonction numpy.ndim() renvoie le nombre de dimensions du tableau.
>>> b = np.array([[1, 2, 3],
[4, 5, 6]])
>>> np.ndim(b)
2
Algèbre
Un avantage des arrays est que les opérateurs mathématiques s'appliquent à tous ses éléments.
Cela permet, par exemple, d'additionner des vecteurs ou des matrices :
>>> a = np.ones(3)
>>> y = np.array([0, 1, 0])
>>> x = np.array([1, 0, 0])
>>> a
array([ 1., 1., 1.])
>>> x
array([1, 0, 0])
>>> y
array([0, 1, 0])
>>> x + y
array([1, 1, 0])

4. >>> a - x - y
array([ 0., 0., 1.])
>>> a * x
array([ 1., 0., 0.])
# somme des éléments du array a
>>> a.sum()
3.0
>>> b = np.arange(2, 10).reshape(2, 4)
>>> b
array([[2, 3, 4, 5],
[6, 7, 8, 9]])
>>> b.sum(axis=0)
array([ 8, 10, 12, 14])
>>> b.sum(axis=1)
array([14, 30])
Génération aléatoire d’une matrice
>>> r = np.random.random((4, 5))
>>> r
array([[ 0.04159733, 0.66203517, 0.75505845, 0.30373412, 0.41154307],
[ 0.19002609, 0.56761014, 0.54222685, 0.29554527, 0.05386348],
[ 0.40999777, 0.28028108, 0.90805301, 0.67776604, 0.55878456],
[ 0.30443061, 0.54716066, 0.03860554, 0.3677808 , 0.39150167]])
Produit terme à terme
Il est possible de réaliser un produit terme à terme grâce à l’opérateur *. Il faut dans ce cas que
les deux tableaux aient la même taille.
>>> a = np.array([[1, 2, 3],
[4, 5, 6]])
>>> b = np.array([[2, 1, 3],
[3, 2, 1]])
>>> a*b
array([[ 2, 2, 9],
[12, 10, 6]])
Produit matriciel - numpy.dot()
Un tableau peut jouer le rôle d’une matrice si on lui applique une opération de calcul matriciel.
Par exemple, la fonction numpy.dot() permet de réaliser le produit matriciel.
>>> a = np.array([[1, 2, 3],
[4, 5, 6]])
>>> b = np.array([[4],
[2],
[1]])
>>> np.dot(a,b)
array([[11],

5. [32]])
Le produit d’une matrice de taille n x m par une matrice m x p donne une matrice n x p.
Transposé
>>> a.T
array([[1, 4],
[2, 5],
[3, 6]])
Tableaux et slicing
Lors de la manipulation des tableaux, on a souvent besoin de récupérer une partie d’un tableau.
Pour cela, Python permet d’extraire des tranches d’un tableau grâce une technique
appelée slicing (tranchage, en français). Elle consiste à indiquer entre crochets des indices pour
définir le début et la fin de la tranche et à les séparer par deux-points :.
>>> a = np.array([12, 25, 34, 56, 87])
>>> a[1:3]
array([25, 34])
>>> a[1:]
array([25, 34, 56, 87])
>>> a[:3]
array([12, 25, 34])
>>> a[:]
array([12, 25, 34, 56, 87])
Slicing des tableaux 2D
>>> a = np.array([[1, 2, 3],
[4, 5, 6]])
>>> a[0,1]
2
>>> a[:,1:3]
array([[2, 3],
[5, 6]])
>>> a[:,1]
array([2, 5])
>>> a[0,:]
array([1, 2, 3])
Warning
a[:,n] donne un tableau 1D correspondant à la colonne d’indice n de a. Si on veut obtenir un
tableau 2D correspondant à la colonne d’indice n, il faut faire du slicing en utilisant a[:,n:n+1].
>>> a[:,1:2]
array([[2],
[5]])