Tutoriel Numpy

Introduction

Ce tutoriel est en cours de rédaction (Permissions: Ouvert en écriture pour les membres du site, en lecture pour le public)

La taille d'une matrice

Pour obtenir la taille d'une matrice il existe la méthode numpy appelée "shape". Par exemple, la matrice suivante a 3 lignes et 2 colonnes, elle est donc de dimension ou taille (3, 2).

$$
\left( \begin{array}{cc}
1 & 4 \\
7 & 2 \\
6 & 3
\end{array}\right)
$$

Exemple d'utilisation:

>>> import numpy as np
>>> m = np.array([[1,4],[7,2],[6,3] ])
>>> m
array([[1, 4],
       [7, 2],
       [6, 3]])
>>> m.shape
(3, 2)
>>> type(m.shape)
<type 'tuple'>

Le nombre d'éléments d'une matrice

Pour obtenir le nombre d'éléments d'une matrice, il existe la méthode numpy appelée "size". En reprenant l'exemple précèdent, le nombre d'éléments de la matrice est égale à 6 (3*2). Exemple d'utilisation:

>>> m.size
6
>>> type(m.size)
<type 'int'>

Les valeurs max et min d'une matrice

Pour obtenir les valeurs max et min d'une matrice deux syntaxes possibles:

>>> np.min(m), np.max(m)
(1, 7)

ou

>>> m.min(), m.max()
(1, 7)

Remarque: il est également possible par exemple de trouver une valeur min supérieure à une valeur donnée. Imaginons qu'on cherche la valeur min mais supérieure à 2 (source):

>>> m[m>2].min()
3
>>> np.min(m[m>2])
3

Le produit matriciel

Pour le produit matriciel, il existe sous numpy la méthode "dot". Imaginons que nous voulions calculer le produit matriciel suivant:

$$
\left( \begin{array}{ccc}
1 & 4 & 2 \\
4 & 5 & 2 \\
6 & 3 & 1
\end{array}\right)
\left( \begin{array}{c}
3 \\
0 \\
2
\end{array}\right)
=
\left( \begin{array}{c}
7 \\
16 \\
20
\end{array}\right)
$$

Pour effectuer cette opération avec numpy il suffit d'écrire les quelques lignes de code suivantes:

>>> import numpy as np
>>> m1 = np.array([[1,4,2],[4,5,2],[6,3,1]])
>>> m1
array([[1, 4, 2],
       [4, 5, 2],
       [6, 3, 1]])
>>> m2 = np.array([3,0,2])
>>> m2 
array([3, 0, 2])
>>> np.dot(m1, m2)
array([ 7, 16, 20])

Calculer les racines d'un polynôme

Avec numpy il est possible de déterminer les racines d'un polynôme avec la méthode root. Par exemple le polynôme suivant possède 3 racines: -4, 2 et -1.

$$P(x)=\frac{x^3}{4}+\frac{3.x^2}{4}-\frac{3.x}{2}-2$$

Exemple:

>>> import numpy as np
>>> coeff = [1.0/4.0,3.0/4.0,-3.0/2.0,-2]
>>> np.roots(coeff)
array([-4.,  2., -1.])

Le déterminant d'une matrice

Pour calculer le déterminant d'une matrice il existe la méthode linalg.det.
Exemple avec la matrice A suivante:

$$
A =
\left( \begin{array}{cc}
-2 & 2 & -3 \\
-1 & 1 & 3 \\
2 & 0 & -1
\end{array}\right)
$$

dont le déterminant est:

$$
det(A) =
\left| \begin{array}{cc}
-2 & 2 & -3 \\
-1 & 1 & 3 \\
2 & 0 & -1
\end{array}\right|
= 18
$$

Avec numpy cela donne:

>>> import numpy as np
>>> m = np.array([[-2,2,-3],[-1,1,3],[2,0,-1]])
>>> np.linalg.det(m)
17.999999999999996

Utiliser une fonction pour calculer les éléments d'une matrice

Il est possible avec numpy de calculer les éléments d'une matrice en passant par une fonction. Imaginons un tableau de données: x = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4] pour lequel on veut calculer sin(xi). Avec python cela donne:

>>> import numpy as np
>>> import math 
>>> x = np.arange(-5,5,1)
>>> x
array([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4])
>>> def function(x):
...     return math.sin(x)
... 
>>> y = function(x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in function
TypeError: only length-1 arrays can be converted to Python scalars

On obtient ici une erreur couramment rencontrée. Pour corriger celle-ci il suffit d'utiliser numpy pour calculer le sinus (np.sin) et non pas le module math (math.sin)
qui ne gère pas bien les matrices. Voici donc la bonne façon de faire:

>>> def function(x):
...     return np.sin(x)
... 
>>> y = function(x)
>>> y
array([ 0.95892427,  0.7568025 , -0.14112001, -0.90929743, -0.84147098,
    0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ])