Calculer avec de grands tableaux NumPy en Python

Vous devez effectuer des calculs sur de grands ensembles de données numériques, tels que des tableaux ou des matrices.

Pour tout calcul lourd impliquant des tableaux, utilisez la bibliothèque NumPy. La principale caractéristique de NumPy est qu’il donne à Python un objet tableau qui est beaucoup plus efficace et mieux adapté au calculs mathématiques qu’une liste Python standard.

Voici un court exemple illustrant les différences de comportement importantes entre les listes et les tableaux NumPy:

>>> # Nombre de listes Python
>>> x = [1, 2, 3, 4]
>>> y = [5, 6, 7, 8]
>>> x * 2
[1, 2, 3, 4, 1, 2, 3, 4]
>>> x + 10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "int") to list
>>> x + y
[1, 2, 3, 4, 5, 6, 7, 8]

>>> # tableaux Numpy
>>> import numpy as np
>>> ax = np.array([1, 2, 3, 4])
>>> ay = np.array([5, 6, 7, 8])
>>> ax * 2
array([2, 4, 6, 8])
>>> ax + 10
array([11, 12, 13, 14])
>>> ax + ay
array([ 6,  8, 10, 12])
>>> ax * ay
array([ 5, 12, 21, 32])
>>>

Comme vous pouvez le voir, les opérations mathématiques de base impliquant des tableaux se comportent différemment. Plus précisément, les opérations scalaires (p. ex., ax* 2 ou ax + 10) appliquent l’opération élément par élément.

De plus, effectuer des opérations mathématiques lorsque les deux opérandes sont des tableaux applique l’opération à tous les éléments et produit un nouveau tableau.

Le fait que les opérations mathématiques s’appliquent simultanément à tous les éléments rend le calcul des fonctions sur l’ensemble d’un tableau très simple et rapide. Par exemple, si vous voulez calculer la valeur d’un polynôme:

>>> def f(x):
...     return 3*x**2 - 2*x + 7
...
>>> f(ax)
array([ 8, 15, 28, 47])
>>>

NumPy propose une collection de “fonctions universelles” qui permettent également des opérations de tableaux. Ce sont des remplacements pour des fonctions similaires que l’on trouve normalement dans le module math. Par exemple:

>>> np.sqrt(ax)
array([ 1.        ,  1.41421356,  1.73205081,  2.        ])
>>> np.cos(ax)
array([ 0.54030231, -0.41614684, -0.9899925 , -0.65364362])
>>>

L’utilisation de fonctions universelles peut être des centaines de fois plus rapide que le fait de parcourir en boucle les éléments du tableau un par un et d’effectuer des calculs en utilisant les fonctions du module math. Par conséquent, vous devriez préférer leur utilisation dans la mesure du possible.

Les tableaux NumPy sont alloués de la même manière qu’en C ou Fortran. Il s’agit de grandes régions de mémoire contiguës constituées d’un type de données homogène.

Pour cette raison, il est possible de faire des tableaux beaucoup plus grands que tout ce que vous mettriez normalement dans une liste Python.

Par exemple, si vous voulez faire une matrice bidimensionnelle de 10.000 par 10.000 flottant, ce n’est pas un problème:

>>> matrice = np.zeros(shape=(10000,10000), dtype=float)
>>> matrice 
array([[ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       ...,
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.]])
>>>

Toutes les opérations habituelles s’appliquent toujours à tous les éléments simultanément:

>>> matrice += 10
>>> matrice
array([[ 10.,  10.,  10., ...,  10.,  10.,  10.],
       [ 10.,  10.,  10., ...,  10.,  10.,  10.],
       [ 10.,  10.,  10., ...,  10.,  10.,  10.],
       ...,
       [ 10.,  10.,  10., ...,  10.,  10.,  10.],
       [ 10.,  10.,  10., ...,  10.,  10.,  10.],
       [ 10.,  10.,  10., ...,  10.,  10.,  10.]])

>>> np.sin(matrice)
array([[-0.54402111, -0.54402111, -0.54402111, ..., -0.54402111,
        -0.54402111, -0.54402111],
       [-0.54402111, -0.54402111, -0.54402111, ..., -0.54402111,
        -0.54402111, -0.54402111],
       [-0.54402111, -0.54402111, -0.54402111, ..., -0.54402111,
        -0.54402111, -0.54402111],
       ...,
       [-0.54402111, -0.54402111, -0.54402111, ..., -0.54402111,
        -0.54402111, -0.54402111],
       [-0.54402111, -0.54402111, -0.54402111, ..., -0.54402111,
        -0.54402111, -0.54402111],
       [-0.54402111, -0.54402111, -0.54402111, ..., -0.54402111,
        -0.54402111, -0.54402111]])
>>>

Un aspect extrêmement remarquable de NumPy est la manière dont il étend la fonctionnalité d’indexation de liste de Python, en particulier avec les tableaux multidimensionnels.

Pour illustrer, faites un tableau simple en deux dimensions et essayez quelques tests:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
>>> a
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

>>> # Selectionner ligne 1
>>> a[1]
array([5, 6, 7, 8])

>>> # Selectionner colonne 1
>>> a[:,1]
array([ 2,  6, 10])

>>> # Sélectionner une sous-région et la modifier
>>> a[1:3, 1:3]
array([[ 6,  7],
       [10, 11]])
>>> a[1:3, 1:3] += 10
>>> a
array([[ 1,  2,  3,  4],
       [ 5, 16, 17,  8],
       [ 9, 20, 21, 12]])

>>> # Diffuser un vecteur de ligne à travers une opération sur toutes les lignes
>>> a + [100, 101, 102, 103]
array([[101, 103, 105, 107],
       [105, 117, 119, 111],
       [109, 121, 123, 115]])
>>> a
array([[ 1,  2,  3,  4],
       [ 5, 16, 17,  8],
       [ 9, 20, 21, 12]])

>>> # Affectation conditionnelle sur un tableau
>>> np.where(a < 10, a, 10)
array([[ 1,  2,  3,  4],
       [ 5, 10, 10,  8],
       [ 9, 10, 10, 10]])
>>>

NumPy est la base d’un grand nombre de bibliothèques scientifiques et techniques en Python. C’est aussi l’un des modules les plus grands et les plus compliqués en usage répandu.

Cela dit, il est toujours possible d’accomplir des choses utiles avec NumPy en commençant par des exemples simples et en continuant à les manipuler.

Une remarque à propos de l’utilisation est qu’il est relativement courant d’utiliser l’instruction import numpy as np, comme indiqué dans la solution.

Ceci raccourcit simplement le nom à quelque chose qui est plus pratique à taper encore et encore dans votre programme.

LAISSER UN COMMENTAIRE

Please enter your comment!
Please enter your name here