Guide: la bibliothèque NumPy

Temps de lecture : 8 minutes
couverture guide numpy

La bibliothèque NumPy est une bibliothèque Python incontournable pour les data scientists : une bonne raison de s’y familiariser.

Les tableaux NumPy ressemblent aux listes Python, mais en beaucoup mieux ! Ils sont bien plus faciles à manipuler : un seul tableau peut remplacer plusieurs listes. Ils calculent aussi plus vite que les listes et sont extrêmement efficaces pour les opérations mathématiques et logiques. C’est un outil puissant à connaître !

Cet article est un aide-mémoire qui donne un aperçu rapide des bases de la bibliothèque NumPy ainsi que des méthodes utiles.

En bref : NumPy est la bibliothèque Python de référence pour manipuler des tableaux numériques. Un tableau NumPy ressemble à une liste Python, mais il calcule plus vite et un seul tableau peut remplacer plusieurs listes. Cet aide-mémoire montre comment créer des tableaux, accéder à leurs éléments, utiliser le broadcasting, faire des calculs matriciels et filtrer avec des masques booléens.

Tu peux aussi exécuter les exemples NumPy dans ce notebook Google Colab : chaque extrait de code est dans sa propre cellule, prêt à être modifié.

Je te montre comment initialiser des tableaux NumPy de plusieurs façons, accéder aux valeurs d’un tableau, effectuer des opérations mathématiques et matricielles, et utiliser les tableaux pour le masquage et les comparaisons. Je trouve les tableaux NumPy très utiles pour résoudre des problèmes data en Python.

Commençons la partie fun : de la pratique et de la bonne humeur.

Comment importer la bibliothèque NumPy ?

Tout d’abord, importe la bibliothèque NumPy avec le code suivant :

import numpy as np
Python

Comment créer un tableau NumPy ?

Voici plusieurs façons d’initialiser un tableau NumPy, selon tes besoins :

array1 = np.array([0, 1, 2, 3, 4, 5])
array1
Python
array([0, 1, 2, 3, 4, 5])
array2 = np.array([[0, 1, 2], [3, 4, 5]])
array2
Python
array([[0, 1, 2],
       [3, 4, 5]])
array3 = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
array3
Python
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
Python
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
Python
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
Python
array([[1., 1.],
       [1., 1.]])

Matrice Identité de dimension 3

array7 = np.identity(3)
array7
Python
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Si tu as une liste que tu souhaites convertir en tableau NumPy, tu peux le faire facilement avec np.array :

lst = [0, 1, 2, 3, 4]
numpy_list = np.array(lst)
numpy_list
Python
array([0, 1, 2, 3, 4])

Comment accéder aux éléments d’un tableau NumPy ?

Tu peux accéder à un élément individuel ou à une tranche de valeurs. Comme pour les listes, le premier élément a l’index 0.

Par exemple, array3[0,0] désigne l’élément situé sur la première ligne et la première colonne. Le premier nombre du tuple [0,0] est l’index de la ligne, le deuxième est l’index de la colonne.

Voici le tableau array3 :

array3
Python
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

Extraire un élément

Remarque : avec NumPy 2, une valeur isolée s’affiche sous la forme np.int64(0) (ou np.float64(9.0)) dans un notebook. Les exemples ci-dessous montrent l’affichage simplifié des anciennes versions ; avec print(), tu obtiens la valeur seule.

array3[0,0]   # accéder à la ligne d'index 0 et colonne d'index 0
Python
0
array3[1,2]   # accéder à la ligne d'index 1, colonne d'index 2
Python
5
array3[0,2]   # accéder à la ligne d'index 0, colonne d'index 2
Python
2
array3[2,1]   # accéder à la ligne d'index 2, colonne d'index 1
Python
7

Extraire un sous-tableau

array3[1:3,1:3]   # extraire un extrait du tableau array3
Python
array([[4, 5],
       [7, 8]])

Qu’est-ce que le broadcasting dans NumPy ?

« Le terme broadcasting décrit comment NumPy traite des tableaux de formes différentes lors d’opérations arithmétiques. » (traduit de la documentation NumPy)

Le broadcasting permet d’effectuer des opérations entre des tableaux de formes différentes, en « étirant » virtuellement le plus petit pour qu’il corresponde au plus grand, sans copier les données.

Pour cela, NumPy compare les formes des deux tableaux dimension par dimension, en partant de la dernière. Deux dimensions sont compatibles lorsque :

  1. elles sont identiques, ou
  2. l’une d’elles est 1

Si ces conditions ne sont pas remplies, NumPy renvoie une erreur ValueError: operands could not be broadcast together, qui indique que les tableaux ont des formes incompatibles.

Prenons un tableau de 6 chiffres de 0 à 5 :

x = np.arange(6)
x
Python
array([0, 1, 2, 3, 4, 5])

L’attribut shape affiche la dimension (la forme) d’un tableau :

x.shape   # retourne la dimension / forme d'un tableau
Python
(6,)

Prenons maintenant y, un tableau contenant cinq 1 :

y = np.ones(5)
y
Python
array([1., 1., 1., 1., 1.])

On vérifie sa forme :

y.shape
Python
(5,)

Essayons d’additionner x et y, dont les formes ne sont pas compatibles. NumPy renvoie une erreur :

x + y
Python
ValueError: operands could not be broadcast together with shapes (6,) (5,)

Pour obtenir le résultat voulu, on utilise la méthode reshape(). Elle modifie la forme du tableau pour le rendre compatible avec l’opération :

z = x.reshape(6,1)
z
Python
array([[0],
       [1],
       [2],
       [3],
       [4],
       [5]])

On peut maintenant additionner z (forme (6, 1)) et y (forme (5,)). Le résultat a la forme (6, 5) :

z + y
Python
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.]])

Comment faire des calculs mathématiques et matriciels avec NumPy ?

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… en une seule ligne de code !

Tu trouveras ci-dessous quelques exemples d’opérations arithmétiques et multiplicatives avec les tableaux NumPy. Les opérations non traitées ici sont décrites dans la documentation officielle.

arr1 = np.ones((3,3))
arr1
Python
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])
arr2 = np.arange(9).reshape(3,3)
arr2
Python
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

Somme de 2 tableaux

arr1 + arr2   # somme de arr1 et arr2
Python
array([[1., 2., 3.],
       [4., 5., 6.],
       [7., 8., 9.]])

Ajouter 1 à chaque valeur d’un tableau

arr1 + 1   # ajoute 1 à chaque élément
Python
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
Python
9.0

Multiplication terme à terme de 2 tableaux

(arr1 + 1) * arr2   # multiplication de 2 tableaux
Python
array([[ 0.,  2.,  4.],
       [ 6.,  8., 10.],
       [12., 14., 16.]])

Produit matriciel de 2 tableaux

np.dot(arr1, arr2)
Python
array([[ 9., 12., 15.],
       [ 9., 12., 15.],
       [ 9., 12., 15.]])

Parmi les autres fonctionnalités intéressantes, on trouve la concaténation, le fractionnement, la transposition (échange des lignes et des colonnes) et l’obtention des éléments de la diagonale.

Concaténer par lignes

np.concatenate((arr1, arr2), axis=0)   # concaténer le long des lignes (axe 0)
Python
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [0., 1., 2.],
       [3., 4., 5.],
       [6., 7., 8.]])

Concaténer par colonnes

np.concatenate((arr1, arr2), axis=1)   # concaténer le long des colonnes (axe 1)
Python
array([[1., 1., 1., 0., 1., 2.],
       [1., 1., 1., 3., 4., 5.],
       [1., 1., 1., 6., 7., 8.]])

À retenir : axis=0 indique que l’on concatène par lignes, et axis=1 par colonnes.

Séparer un tableau en 3 tableaux

np.split(arr2,3)   # séparer le tableau arr2 en 3 tableaux
Python
[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
Python
[array([[0],
        [3],
        [6]]), array([[1],
        [4],
        [7]]), array([[2],
        [5],
        [8]])]

Supprimer une ligne d’un tableau

np.delete(arr2, 2, axis=0)   # supprime la ligne d'index 2
Python
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
Python
array([[0, 1],
       [3, 4],
       [6, 7]])

Transposition de tableau

np.transpose(arr2)
Python
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
Python
array([0, 4, 8])

Comment comparer et filtrer un tableau NumPy avec un masque booléen ?

Une chose utile avec les tableaux NumPy est de comparer un tableau à une valeur ou à un autre tableau. La comparaison renvoie un tableau de booléens.

array1
Python
array([0, 1, 2, 3, 4, 5])

Retourner un tableau de booléens

array1 > 2   # retourne un tableau de booléens
Python
array([False, False, False,  True,  True,  True])

On peut utiliser ce tableau booléen à notre avantage : c’est le masquage booléen. En l’utilisant comme masque, on sélectionne le sous-ensemble de données qui nous intéresse.

mask = array1 > 2
array1[mask]
Python
array([3, 4, 5])

Il existe de nombreux autres opérateurs de comparaison : == (égalité), != (différence), <= (inférieur ou égal)…

On peut même combiner plusieurs conditions avec & (« ET ») ou | (« OU »). Chaque condition doit être placée entre parenthèses :

mask = (array1 > 4) | (array1 < 2)
array1[mask]
Python
array([0, 1, 5])

Pour pratiquer NumPy et Pandas sur des jeux de données réels, le parcours Analyse et visualisation des données de DataXp te fait pratiquer sur des exercices corrigés, avec un coach IA qui t’aide quand tu bloques. Les premiers modules sont gratuits.

Questions fréquentes sur NumPy

Quelle est la différence entre un tableau NumPy et une liste Python ?

Un tableau NumPy ressemble à une liste, mais il est plus facile à manipuler (un seul tableau peut remplacer plusieurs listes), il calcule plus vite et il est très efficace pour les opérations mathématiques et logiques.

Qu’est-ce que le broadcasting dans NumPy ?

C’est la façon dont NumPy traite des tableaux de formes différentes lors d’opérations arithmétiques : il « étire » virtuellement le plus petit tableau pour qu’il corresponde au plus grand, sans copier les données. NumPy compare les formes dimension par dimension, en partant de la dernière : deux dimensions sont compatibles si elles sont identiques ou si l’une d’elles vaut 1.

Que faire quand NumPy renvoie « operands could not be broadcast together » ?

Cette ValueError indique que les tableaux ont des formes incompatibles. Utilise reshape() pour modifier la forme d’un tableau : par exemple, un tableau de forme (6, 1) et un tableau de forme (5,) s’additionnent et donnent un résultat de forme (6, 5).

Comment filtrer un tableau NumPy avec une condition ?

Avec le masquage booléen : comparer le tableau à une valeur renvoie un tableau de booléens, que tu utilises comme masque pour sélectionner les éléments voulus. Pour combiner plusieurs conditions, utilise & (ET) ou | (OU), chaque condition entre parenthèses.

À quoi servent axis=0 et axis=1 pour concaténer des tableaux ?

axis=0 concatène par lignes et axis=1 par colonnes.

Pour aller plus loin avec Python, consulte aussi notre guide des 21 astuces et concepts Python pour améliorer ton code.

Étiquettes de la publication :

Publications similaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *