Tableaux et matrices : module numpy

De WikiMéca
Sauter à la navigation Sauter à la recherche

La bibliothèque NumPy [1] permet d’effectuer des calculs numériques avec Python. Elle introduit une gestion facilitée des tableaux de nombres et permet également de travailler sur les matrices.

Il faut au départ importer le package numpy avec l’instruction suivante (on utilise par convention l'alias "np":

import numpy as np

Tableaux - numpy.array()

Création

Les tableaux (en anglais, array) peuvent être créés avec numpy.array(). On utilise des crochets pour délimiter les listes d’éléments dans les tableaux.

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

Accès aux éléments d’un tableau

>>> a
array([[1, 2, 3],
       [4, 5, 6]])

>>> a[0]  #première ligne
array([1, 2, 3])


>>> a[1]  #deuxième ligne
array([4, 5, 6])


>>> a[-1] #dernière ligne (équivalent à la commande précédente)
array([4, 5, 6])

>>> a[0,-1] #dernière valeur de la première ligne
3

La fonction numpy.arange()

La fonction numpy.arange(valeur_départ, valeur_fin, pas) permet d’obtenir un tableau 1D allant d’une valeur de départ à une valeur de fin (exclue) avec un pas. La valeur de départ est optionnelle (0 par défaut) et le pas également (1 par défaut). elle est un équivalent de range mais renvoie un tableau (type array), ce qui évite une conversion. A noter que la fonction numpy.arange() accepte des flottants :

>>> np.arange(5)  # équivalent à range(5) mais renvoie un tableau
array([0, 1, 2, 3, 4])

>>> np.arange(5, dtype = np.float16)   #avec des flottants
array([0., 1., 2., 3., 4.], dtype=float16)

>>> np.arange(2, 7)
array([2, 3, 4, 5, 6])

>>> np.arange(2, 7, 0.5) # avec un pas non entier
array([2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5])

>>> np.arange(2.2, 7, 0.5) # avec un pas non entier et une borne non entière
array([2.2, 2.7, 3.2, 3.7, 4.2, 4.7, 5.2, 5.7, 6.2, 6.7])

La fonction numpy.linspace()

La fonction numpy.linspace(valeur_départ, valeur_fin, nb_éléments) permet d’obtenir un tableau 1D allant d’une valeur de départ à une valeur de fin avec un nombre donné d’éléments.


>>> np.linspace( 1, 10, 10)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

>>> np.linspace( 3, 10, 5)
array([ 3.  ,  4.75,  6.5 ,  8.25, 10.  ])

Fonctions mathématiques sur un tableau

NumPy dispose d’un grand nombre de fonctions mathématiques qui peuvent être appliquées directement à un tableau. Dans ce cas, la fonction est appliquée à chacun des éléments du tableau.

>>> x = np.linspace(-np.pi/2, np.pi/2, 3)
>>> x
array([-1.57079633,  0.        ,  1.57079633])
>>> y = np.sin(x)
>>> y
array([-1.,  0.,  1.])

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]])
>>> np.size(b)
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)
(4,)
>>> b = np.array([[1, 2, 3],
                  [4, 5, 6]])
>>> np.shape(b)
(2, 3)

On distingue bien ici que a et b correspondent à des tableaux 1D et 2D, respectivement.

Produit terme à terme

Il est possible de réaliser un produit terme à terme de deux vecteurs ou matrices 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],
       [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 = np.array([[1, 2, 3],
                  [4, 5, 6]])
>>> a.T
array([[1, 4],
       [2, 5],
       [3, 6]])

Complexe conjugué - numpy.conj()

>>> u = np.array([[  2j, 4+3j],
                  [2+5j, 5   ],
                  [   3, 6+2j]])
>>> np.conj(u)
array([[ 0.-2.j,  4.-3.j],
       [ 2.-5.j,  5.+0.j],
       [ 3.+0.j,  6.-2.j]])

Transposé complexe conjugué

>>> np.conj(u).T
array([[ 0.-2.j,  2.-5.j,  3.+0.j],
       [ 4.-3.j,  5.+0.j,  6.-2.j]])

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])

Dans la tranche [n:m], l’élément d’indice n est inclus, mais l’élément d’indice m est exclu.

Il est aussi possible de ne pas mettre de début ou de fin.

>>> 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])

Avertissement:

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]])

Tableaux de 0 - numpy.zeros()

zeros(n) renvoie un tableau 1D de n zéros.

>>> np.zeros(3)
array([ 0.,  0.,  0.])

zeros((m,n)) renvoie tableau 2D de taille m x n, c’est-à-dire de shape (m,n).

>>> np.zeros((2,3))
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])

Tableaux de 1 - numpy.ones()

>>> np.ones(3)
array([ 1.,  1.,  1.])
>>> np.ones((2,3))
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

Matrice identité - numpy.eye()

eye(n) renvoie tableau 2D carré de taille n x n, avec des uns sur la diagonale et des zéros partout ailleurs.

>>> np.eye(3)
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])

Déterminant - numpy.linalg.det()

>>> from numpy.linalg import det
>>> a = np.array([[1, 2],
                  [3, 4]])
>>> det(a)
-2.0

Inverse - numpy.linalg.inv()

>>> from numpy.linalg import inv
>>> a = np.array([[1, 3, 3],
                  [1, 4, 3],
                  [1, 3, 4]])
>>> inv(a)
array([[ 7., -3., -3.],
       [-1.,  1.,  0.],
       [-1.,  0.,  1.]])

Résolution d’un système d’équations linéaires - numpy.linalg.solve()

Pour résoudre le système d’équations linéaires:

>>> a = np.array([[3,1], [1,2]])
>>> b = np.array([9,8])
>>> x = np.linalg.solve(a, b)
>>> x
array([ 2.,  3.])

Pour vérifier que la solution est correcte :

>>> np.allclose(np.dot(a, x), b)
True

Valeurs propres et vecteurs propres - numpy.linalg.eig()

>>> from numpy.linalg import eig
>>> A = np.array([[ 1, 1, -2 ], [-1, 2, 1], [0, 1, -1]])
>>> A
array([[ 1,  1, -2],
       [-1,  2,  1],
       [ 0,  1, -1]])
>>> D, V = eig(A)
>>> D
array([ 2.,  1., -1.])
>>> V
array([[  3.01511345e-01,  -8.01783726e-01,   7.07106781e-01],
       [  9.04534034e-01,  -5.34522484e-01,  -3.52543159e-16],
       [  3.01511345e-01,  -2.67261242e-01,   7.07106781e-01]])

Les colonnes de V sont les vecteurs propres de A associés aux valeurs propres qui apparaissent dans D.

Changement de la taille d’un tableau

Il est possible de changer la taille d’un tableau en utilisant l’attribut shape de ce tableau.

>>> u = np.arange(1, 16)
>>> u
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
>>> np.shape(u)
(15,)
>>> u.shape = (3, 5)
>>> u
array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10],
       [11, 12, 13, 14, 15]])
>>> np.shape(u)
(3, 5)

Autres pages de la catégorie "Informatique"

Pages relatives à l'informatique en CPGE scientifiques.

Bases du langage Python

Algorithmes et méthodes numériques‎