Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Python pour la Data Science
  3. Maîtriser la librairie NumPy
Extrait - Python pour la Data Science Analysez vos données par la pratique avec NumPy, Pandas, Matplotlib et Seaborn
Extraits du livre
Python pour la Data Science Analysez vos données par la pratique avec NumPy, Pandas, Matplotlib et Seaborn
4 avis
Revenir à la page d'achat du livre

Maîtriser la librairie NumPy

Introduction à NumPy

NumPy est la librairie Python dédiée au calcul scientifique fournissant des fonctions très performantes de calcul, mais aussi des structures de données, tout aussi performantes.

En Data Science, il est essentiel d’avoir des structures adaptées pour stocker et manipuler de grandes quantités de données. C’est là qu’intervient NumPy, qui intègre une nouvelle structure de données en Python, les ndarrays (tableaux à N dimensions, en français, N représentant un chiffre), qui sont des tableaux multidimensionnels ou matrices. Il est important de noter que cette structure de données permet de stocker des données uniquement de même type (uniquement des nombres entiers par exemple).

Les ndarrays sont optimisés pour le stockage de données, mais aussi pour leur manipulation et plus encore pour les calculs, car ceux-ci peuvent être vectorisés. NumPy peut gérer de très gros tableaux et est très performante en temps de calcul sur ces tableaux : les ndarrays prennent en effet moins de place mémoire que d’autres objets Python, comme par exemple les listes. C’est pour cela que cette librairie a été développée et qu’elle est si utilisée : elle est très performante. C’est également pour cette raison...

Les tableaux NumPy

1. Créer un ndarray

a. Créer un ndarray à partir de listes

On peut créer un tableau NumPy à partir d’une liste en utilisant la fonction array() afin de convertir cette liste en tableau.

Syntaxe

import numpy as np 
notre_tableau=np.array([élément1,élément2,élément3,élément4]) 

Exemple de code

import numpy as np 
notre_tableau=np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17, 
18,19,20]) 
print(notre_tableau) 
type(notre_tableau) 

Résultat

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20] 
numpy.ndarray 

Ici, on importe la librairie NumPy, on crée un tableau à partir d’une liste, on affiche ce tableau avec print() et on affiche le type de l’objet notre_tableau. En résultat, on a notre premier array NumPy, qui est un tableau à une dimension ici, qu’on pourrait considérer comme une liste, mais qui est bien de type ndarray.

Pour créer un tableau bidimensionnel, il faut créer une liste contenant des listes, ce qui permet de représenter un tableau à deux entrées : les lignes et les colonnes. Pour cela, il suffit de considérer que la liste qu’on donne à la fonction array() est une liste de lignes et que les listes contenues dans cette liste représentent les colonnes. Ainsi, chaque ligne contient une liste qui correspond aux colonnes de cette ligne.

Syntaxe

mon_array_bidimensionnel=np.array([[élément ligne 1 colonne 1, 
élément ligne 1 colonne 2,élément ligne 1 colonne 3], 
[élément ligne 2 colonne 1, élément ligne 2 colonne 2,  
élément ligne 2 colonne 3]]) 

Code

import numpy as np 
mon_array_bidimensionnel=np.array([[1,2,3],[4,5,6],[7,8,9]]) 
print(mon_array_bidimensionnel) 

Résultat

[[1 2 3] 
 [4 5 6] 
 [7 8 9]] 

On remarque tout de suite que, visuellement, cela ressemble à un tableau à deux dimensions, dont la première ligne contient trois colonnes avec les chiffres 1,2,3, la deuxième ligne (la deuxième liste de la liste principale) également trois colonnes avec les chiffres 4, 5, 6, etc.

Il s’agit d’un tableau d’entiers...

Les opérations mathématiques avec NumPy

1. Les opérations arithmétiques

Il est possible d’ajouter, de soustraire, de multiplier ou de diviser des valeurs sur un ndarray. Il y a des fonctions NumPy dédiées à cette tâche, ce sont les fonctions add() (ajouter), subtract() (soustraire), multiply() (multiplier) et divide() (diviser).

Syntaxe

import numpy as np 
np.add(mon_array,nombre) 
np.add(mon_array,mon_array2) 

Ceci est la syntaxe générale de la fonction add() ; celle des autres fonctions est la même, seul le résultat change.

On peut additionner l’ensemble des éléments d’un tableau avec un nombre, ou encore additionner deux tableaux.

Très simplement, créons un tableau à deux dimensions, comme suit.

Code

mon_tableau=np.array([[10,11,12],[13,14,15],[16,17,18]]) 
mon_tableau 

Résultat

array([[10, 11, 12], 
       [13, 14, 15], 
       [16, 17, 18]]) 

C’est un tableau à deux dimensions : trois lignes et trois colonnes.

Si on veut ajouter la valeur 10 à l’ensemble des valeurs de ce tableau, on utilisera la fonction add() de la même manière que la syntaxe présentée précédemment.

Code

import numpy as np 
np.add(mon_tableau,10) 

Résultat

array([[20, 21, 22], 
       [23, 24, 25], 
       [26, 27, 28]]) 

Si on veut multiplier l’ensemble des valeurs par 20, on utilisera cette fois-ci la fonction multiply().

Code

import numpy as np 
np.multiply(mon_tableau,20) 

Et de même pour soustraire et diviser, avec les fonctions respectives subtract() et divide().

Comme nous l’avons montré dans la syntaxe, il est possible de faire ces calculs entre deux tableaux ndarray. Créons un nouveau tableau pour illustrer les exemples.

Code

mon_tableau2=np.array([10,20,30]) ...

Inspecter un tableau grâce aux attributs de NumPy

Les objets de classe ndarray (les tableaux NumPy) possèdent un ensemble d’attributs qui permettent de les inspecter. La liste de ces attributs est disponible dans la documentation de NumPy, dans la partie Attributes :  https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html

Nous allons en voir quelques-uns ensemble :

  • Il est possible de connaître le type des éléments d’un tableau avec l’attribut dtype.

  • Il est possible de connaître le nombre d’éléments contenus dans un tableau grâce à l’attribut size.

  • Il est possible de faire la transposée d’un tableau, c’est-à-dire de permuter les dimensions (les lignes devenant les colonnes et les colonnes les lignes), grâce à l’attribut T.

  • Il est possible de connaître la dimension d’un tableau avec l’attribut ndim, afin de savoir s’il s’agit d’un tableau à une dimension, deux dimensions, trois dimensions, etc.

  • Il est possible de connaître la taille des dimensions d’un tableau, c’est-à-dire le nombre de lignes et de colonnes, grâce à l’attribut shape.

Syntaxe d’utilisation des attributs

mon_array.attribut 

Pour rappel, l’attribut est une variable liée à une classe d’objets. Il permet d’accéder aux...

Manipuler des tableaux NumPy

1. Ajouter et supprimer des éléments dans un tableau

a. Ajouter des éléments dans un tableau

Pour ajouter des éléments, il y a différentes manières de faire. Soit on ajoute les éléments à la fin du tableau avec la fonction append() de NumPy, soit on les insère à une position donnée avec la fonction insert() de NumPy.

Syntaxe d’utilisation de la fonction append()

import numpy as np 
np.append(mon_array, elements_a_ajouter) 

Le cas d’utilisation le plus simple concerne les tableaux à une dimension, pour lesquels il suffit de donner une liste de valeurs. Pour l’exemple, reprenons l’objet notre_tableau, qui contient une suite de valeurs allant de 1 à 20, et ajoutons cinq nouvelles valeurs à la suite du tableau.

Code

np.append(notre_tableau,[21,22,23,24,25]) 

Résultat

array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 
       18, 19, 20, 21, 22, 23, 24, 25]) 

On a bien ajouté les valeurs 21, 22, 23, 24, 25 en fin de tableau avec la fonction append().

Avec un tableau à deux dimensions, on peut préciser selon quel axe on souhaite ajouter les valeurs : on peut spécifier si on souhaite ajouter une colonne, une ligne, ou encore ne rien spécifier et les éléments seront ajoutés à la suite. Attention, si on souhaite ajouter une ligne ou une colonne, il faut que ce qu’on donne comme éléments à append soit de même structure que le tableau auquel on ajoute la ligne ou la colonne.

Exemple avec iris, imaginons qu’on veuille ajouter une ligne à la fin du tableau.

Code

np.append(iris,[[10,10,10,10,10]], axis=0) 

Résultat

array([[ 5.1,  3.5,  1.4,  0.2,  1. ], 
... 
[ 5.9,  3. ,  5.1,  1.8,  3. ], 
[10. , 10. , 10. , 10. , 10. ]]) 

Ici, les doubles crochets permettent de donner un tableau à deux dimensions en entrée à append(), contenant cinq valeurs : cela est nécessaire puisqu’il y a cinq colonnes dans le tableau. En donnant le bon nombre de valeurs entre doubles crochets, on respecte la structure du tableau iris et la fonction append() fonctionne....

Introduction aux matrices avec NumPy

Un tableau à deux dimensions peut être considéré comme une matrice. Toutefois, NumPy propose un type particulier pour bien préciser que le tableau est une matrice, il s’agit du type mat.

Syntaxe pour transformer un tableau de type ndarray en matrice de type mat :

import numpy as np 
ma_matrice=np.mat(mon_array) 

La fonction mat() de NumPy permet de facilement faire cette conversion.

Il est ensuite possible de faire des opérations matricielles (multiplication par un scalaire, produit matriciel, transposition, etc.). Nous ne développerons pas les matrices dans ce livre, toutefois, voici les syntaxes des opérations matricielles élémentaires.

Les matrices, tout comme les tableaux NumPy, possèdent l’attribut T pour générer la transposée de la matrice. Mais les matrices possèdent aussi des attributs supplémentaires spécifiques, comme l’attribut .H pour générer la transposée conjuguée et l’attribut .I pour générer l’inverse de la matrice.

Syntaxes

ma_matrice.T 
ma_matrice.H 
ma_matrice.I 

Pour obtenir le produit d’une matrice par elle-même, on utilisera la syntaxe :

ma_matrice**2 

On obtient ainsi la matrice résultant du produit ma_matrice*ma_matrice.

Si ma_matrice est de type ndarray et qu’on fait...