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 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.

Numpy

Tout d’abord, vous devez importer 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]) # tableau dimensionnel
array1
array([0, 1, 2, 3, 4, 5])
array2 = np.array([[0, 1, 2], [3, 4, 5]]) # tableau dimensionnel
array2
array([[0, 1, 2],
       [3, 4, 5]])
array3 = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) # tableau dimensionnel
array3
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

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

2. Tableau 4 lignes x 3 colones contenant des zéros:

array5 = np.zeros((4,3)) # tableau contenant 4 lignes et 3 colonnes de 0
array5
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

3. Tableau 2 x 2 contenant des 1:

array6 = np.ones((2,2)) # tableau contenant 2 lignes 2 colonnes de 1
array6
array([[1., 1.],
       [1., 1.]])

4. Matrice Identité de dimension 3:

array7 = np.identity(3) # Matrice Identité de dimension 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]])

1. 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

2. 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 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, «A partir de deux tableaux, NumPy compare leurs formes élément par élément. Deux dimensions sont compatibles lorsque:

  1. elles sont identiques, ou
  2. 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 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 de 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 # domme 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 par lignes  (axis = 0)
array([[ 9., 12., 15.],
       [ 9., 12., 15.],
       [ 9., 12., 15.]])

Concaténer par colonnes:

np.concatenate((arr1, arr2), axis=1) # concaténer par colonnes (axis = 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]])]

A 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 Numpy de façons différentes.