Rapidité d’exécution#

Un autre avantage important de NumPy est sa rapidité. Prenons l’exemple ci-dessous dans lequel nous créons une liste ou un ndarray de 10,000,000 d’éléments. Ensuite, nous multiplions chaque élément par 2.

Note 1: pour comparer uniquement la vitesse de création de la liste de valeurs, nous n’imprimons pas cette liste (car cela nécessite également du temps).

Note 2: %%timeit fonctionne dans un environement IPython (Interactive Python). Pour plus d’informations, vous pouvez consulter :

• https://ipython.org/ipython-doc/dev/interactive/magics.html

• https://docs.python.org/fr/3/library/timeit.html

Le premier script ci-dessous initialise une liste de 10 millions d’éléments ainsi qu’une liste vide. Ensuite, le script parcourt l’entièreté de la première liste, multiplie chaque élément par 2 et insère cette valeur dans la deuxième liste (celle qui était vide au départ).

%%timeit

my_list = list(range(10_000_000))
double_list = []
for item in my_list:
    double_list.append(2*item)
    
# print(double_list[:10])

1.44 s ± 276 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Une possibilité pour améliorer la rapidité d’exécution du code est de le vectoriser, c’est-à-dire que l’opération “multiplier par 2” est appliqué sur l’entièreté du vecteur. Les compréhensions de liste permettent d’arriver à ce résultat.

%%timeit

my_list = list(range(10_000_000))
double_list = [2*x for x in my_list]

# print(double_list[:10])

764 ms ± 16.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Les deux exemples précédents utilisent les listes. Le script ci-dessous utilise le ndarray de NumPy. La diminution du temps nécessaire à accomplir la tâche est significative.

%%timeit

my_array = np.arange(10_000_000)
double_array = my_array * 2

#print(double_array[:10])

30.1 ms ± 785 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

Fonctions statistiques#

NumPy contient également une liste importante de fonctions statistiques très utiles. Pour la plupart des fonctions ci-dessous, le nom est sufisamment explicite pour comprendre l’utilité de la fonction:

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

print(np.sum(x))
print(np.mean(x))
print(np.min(x))
print(np.max(x))
print(np.median(x))
print(np.std(x))            # standard deviation = ecart-type 
print(np.std(x, ddof=1))    # standard deviation with 1 delta degree of freedom
print(np.var(x))            # variance 
print(np.var(x, ddof=1))    # variance with 1 delta degree of freedom 
print(np.quantile(x, 0.25)) # first quartile = premier quartile 
print(np.quantile(x, 0.75)) # third quartile = troisieme quartile 

55
5.5
1
10
5.5
2.8722813232690143
3.0276503540974917
8.25
9.166666666666666
3.25
7.75

math vs NumPy#

Si nous prenons le cas de la fonction exponentielle, \(f(x) = e^x\), les modules math et NumPy permettent d’obtenir la valeur. La différence principale réside dans le fait que la fonction math.exp() ne fonctionne qu’avec un scalaire alors que np.exp() peut être appliqué soit sur un scalaire, soit sur un vecteur.

import math

%%timeit

x = list(range(1, 100))
y = [math.exp(x) for x in x]

22.8 µs ± 426 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

%%timeit

x = np.arange(1, 100)
y = np.exp(x)

3.65 µs ± 98.5 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

Il en est de même pour la fonction racine carré, \(f(x) = \sqrt{x}\).

%%timeit 

x = list(range(1, 10000))
y = [math.sqrt(x) for x in x]

2.77 ms ± 74.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%%timeit

x = np.arange(1, 10000)
y = np.sqrt(x)

24.2 µs ± 2.22 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

Array multidimensionnel#

Jusqu’à présent, nous avons principalement considéré des vecteurs. NumPy permet également de travailler avec des array multidimensionnel, notamment des array de dimension 2, ce qui correspond d’un point de vue mathématique à une matrice.

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

Tout ce que nous venons de découvrir sur les vecteurs peut donc également s’appliquer aux matrices. Prenons l’exemple de la fonction somme:

np.sum(matrix)

45

En spécifiant en paramètre axis=0, la fonction somme s’appliquera colonne par colonne.

np.sum(matrix, axis=0)

array([12, 15, 18])

De même, en spécifiant axis=1, la fonction somme s’appliquera ligne par ligne.

np.sum(matrix, axis=1)

array([ 6, 15, 24])

matrix = np.array([[1, 2],
                   [3, 4]])

np.linalg.det(matrix)

-2.0000000000000004

from numpy.linalg import det 

matrix = np.array([[1, 2],
                   [3, 4]])

det(matrix)

-2.0000000000000004