La bibliothèque NumPy est une bibliothèque Python importante pour les Data Scientists, une bonne raison de s’y familiariser. Les tableaux Numpy sont comme des listes Python, mais en beaucoup mieux ! En effet, il est beaucoup plus facile de manipuler un tableau Numpy que de manipuler une liste Python. Vous pouvez utiliser un tableau Numpy au lieu d’avoir plusieurs listes Python. Les tableaux Numpy calculent également plus rapidement que les listes et sont extrêmement efficaces pour effectuer des opérations mathématiques et logiques. C’est un outil puissant à connaître !
Cet article constitue un aide-mémoire qui donne un aperçu rapide des bases de la bibliothèque NumPy ainsi que des méthodes utiles. Je vous montrerai comment initialiser des tableaux Numpy de plusieurs façons, accéder aux valeurs dans les tableaux, effectuer des opérations mathématiques et matricielles, et utiliser des tableaux aussi bien pour le masquage que pour les comparaisons. Je trouve les tableaux NumPy très utiles à utiliser pour résoudre des problèmes data en Python.
Commençons la partie fun maintenant : de la pratique et de la bonne humeur.
Bibliothèque NumPy
Tout d’abord, vous devez importer la bibliothèque Numpy avec le code suivant :
import numpy as np
Plusieurs façons de créer des tableaux Numpy
Contrairement à une liste, vous ne pouvez pas créer de tableaux Numpy vides. Vous trouverez ci-dessous plusieurs façons d’initialiser un tableau Numpy en fonction de vos besoins:
array1 = np.array([0, 1, 2, 3, 4, 5]) array1
array([0, 1, 2, 3, 4, 5])
array2 = np.array([[0, 1, 2], [3, 4, 5]]) array2
array([[0, 1, 2],
[3, 4, 5]])array3 = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) array3
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])Tableau contenant les chiffres de 0 à 9
array4 = np.array(range(10)) # tableau avec des chiffres de 0 à 9 array4
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Tableau 4 lignes x 3 colonnes contenant des zéros
array5 = np.zeros((4,3)) array5
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])Tableau 2 x 2 contenant des 1
array6 = np.ones((2,2)) array6
array([[1., 1.],
[1., 1.]])Matrice Identité de dimension 3
array7 = np.identity(3) array7
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])Si vous avez une liste que vous souhaitez convertir en tableau Numpy, nous pouvons facilement la convertir :
lst = [0, 1, 2, 3, 4] numpy_list = np.array(lst) numpy_list
array([0, 1, 2, 3, 4])
Accéder aux éléments d’un tableau
Nous pouvons accéder à un élément individuel ou à une tranche de valeurs. Semblable aux listes, le premier élément est indexé à 0. Par exemple, array1[0,0] indique que nous accédons à la première ligne et à la première colonne. Le premier nombre du tuple [0,0] indique l’index de la ligne et le deuxième nombre indique l’index de la colonne :
array3
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])Extraire un élément
array3[0,0] # accéder à la ligne d'index 0 et colonne d'index 0
0
array3[1,2] # accéder la ligne d'index 1, colonne d'index 2
5
array3[0,2] # accéder à la ligne d'index 0, colonne d'index 2
2
array3[2,1] # accéder à la ligne d'index 2, colonne d'index 1
7
Extraire un sous-tableau
array3[1:3,1:3] # extraire un extrait du tableau array3
array([[4, 5],
[7, 8]])Broadcasting
« Le terme broadcasting décrit comment la bibliothèque Numpy traite des tableaux de formes différentes lors d’opérations arithmétiques. » – SciPy.org
Le broadcasting est un moyen d’obtenir le produit résultant de deux tableaux.
Selon la documentation, «À partir de deux tableaux, NumPy compare leurs formes élément par élément. Deux dimensions sont compatibles lorsque:
- elles sont identiques, ou
- l’une d’elles est 1
Si ces conditions ne sont pas remplies, une erreur « ValueError: frames are not aligned » est retournée, indiquant que les tableaux ont des formes incompatibles.”
Soit un tableau de 6 chiffres de 0 à 5:
x = np.arange(6) x
array([0, 1, 2, 3, 4, 5])
La méthode permet d’afficher la dimension ou forme d’un tableau :
x.shape # retourne la dimension / forme d'un tableau
(6,)
Soit y un tableau contenant cinq 1:
y = np.ones(5) y
array([1., 1., 1., 1., 1.])
On vérifie sa dimension :
y.shape
(5,)
Tentative d’addition des 2 tableaux x et y de dimension non compatible (retourne une erreur) :
x + y
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) in () ----> 1 x + y ValueError: operands could not be broadcast together with shapes (6,) (5,)
Afin d’obtenir le résultat correct, nous utilisons la méthode .reshape(). Cette méthode modifie la forme du tableau afin que nous puissions le rendre compatible pour les opérations Numpy.
z = x.reshape(6,1) z
array([[0],
[1],
[2],
[3],
[4],
[5]])On additionne de cette façon z et y:
z + y
array([[1., 1., 1., 1., 1.],
[2., 2., 2., 2., 2.],
[3., 3., 3., 3., 3.],
[4., 4., 4., 4., 4.],
[5., 5., 5., 5., 5.],
[6., 6., 6., 6., 6.]])Calculs mathématiques et matriciels
L’une des raisons pour lesquelles j’adore les tableaux Numpy c’est qu’ils sont très faciles à manipuler. Concaténer, ajouter, multiplier, transposer avec une seule ligne de code !
Vous trouverez ci-dessous quelques exemples d’opérations arithmétiques et multiplicatives variées avec les tableaux Numpy. Les opérations non traitées ci-dessous peuvent être trouvées dans la documentation ici.
arr1 = np.ones((3,3)) arr1
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])arr2 = np.arange(9).reshape(3,3) arr2
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])Somme de 2 tableaux
arr1 + arr2 # somme de arr1 et arr2
array([[1., 2., 3.],
[4., 5., 6.],
[7., 8., 9.]])Ajouter 1 à chaque valeur d’un tableau
arr1 + 1 # ajoute 1 à chaque élément
array([[2., 2., 2.],
[2., 2., 2.],
[2., 2., 2.]])Sommer toutes les valeurs d’un tableau
np.sum(arr1) # calcule la somme des valeurs de arr1
9.0
Multiplication de 2 tableaux
(arr1 +1) * arr2 # multiplication de 2 tableaux
array([[ 0., 2., 4.],
[ 6., 8., 10.],
[12., 14., 16.]])Produit scalaire de 2 matrices
np.dot(arr1, arr2)
array([[ 9., 12., 15.],
[ 9., 12., 15.],
[ 9., 12., 15.]])Parmi les autres fonctionnalités intéressantes figurent la concaténation, le fractionnement, la transposition (changement d’éléments d’une rangée à l’autre et vice versa) et l’obtention des éléments en diagonale.
Concaténer par lignes
np.concatenate((arr1, arr2), axis=0) # concaténer le long des lignes (axe 0)
array([[ 9., 12., 15.],
[ 9., 12., 15.],
[ 9., 12., 15.]])Concaténer par colonnes:
np.concatenate((arr1, arr2), axis=1) # concaténer le long des colonnes (axe 1)
array([[1., 1., 1., 0., 1., 2.],
[1., 1., 1., 3., 4., 5.],
[1., 1., 1., 6., 7., 8.]])Séparer un tableau en 3 tableaux
np.split(arr2,3) # séparer le tableau arr2 en 3 tableaux
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
Séparer un tableau horizontalement
np.hsplit(arr2,3) # séparer le tableau arr2 horizontalement
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]À retenir, axis = 0 indique que nous voulons concaténer par rangées. Si au lieu de cela nous voulons concaténer par colonnes, nous utilisons axis = 1.
Supprimer une rangée d’un tableau
np.delete(arr2,2,axis=0) # supprime la ligne d'index 2
array([[0, 1, 2],
[3, 4, 5]])Supprimer une colonne d’un tableau
np.delete(arr2,2,axis=1) # supprime la colonne d'index 2
array([[0, 1],
[3, 4],
[6, 7]])Transposition de tableau
np.transpose(arr2)
array([[0, 3, 6],
[1, 4, 7],
[2, 5, 8]])Obtenir les valeurs de la diagonale d’un tableau
arr2.diagonal() # obtenir les éléments de la diagonale de arr2
array([0, 4, 8])
Comparaisons et masques
Une chose utile que l’on peut avec les tableaux Numpy est de comparer un tableau à un autre. Une matrice booléenne est renvoyée après la comparaison.
array1
array([0, 1, 2, 3, 4, 5])
Retourner un tableau de booléens
array1 > 2 # retourne un tableau de booléens
array([False, False, False, True, True, True])
Nous pouvons utiliser cette matrice booléenne à notre avantage. Autrement dit, nous pouvons faire du masquage booléen. Avec cette matrice booléenne comme masque, nous pouvons l’utiliser pour sélectionner le sous-ensemble particulier de données qui nous intéresse.
mask = array1 > 2 array1[mask]
array([3, 4, 5])
En outre, nous disposons de nombreux autres opérateurs de comparaison pour comparer deux tableaux tels que == (égalité), != (Non-égalité), <= (inférieur ou égal à). Nous pouvons même combiner deux déclarations booléennes & (pour les conditions « ET ») ou | (pour les conditions « OU »).
mask = (array1 > 4) | (array1 < 2) array1[mask]
array([0, 1, 5])
Merci d’avoir lu ! J’espère que cet article vous a été profitable. Commentez ci-dessous si vous utilisez la bibliothèque NumPy de façon différente et regardez mes formations pour aller plus loin.
