Découvrez les librairies Python pour la Data Science

Découvrez NumPy

Les Data Analysts ou Data Scientists ont au quotidien à manipuler des données en grande quantité et de sources très variées. Celles-ci sont généralement représentées sous la forme de listes ou tableaux de nombres.

Cependant, les objets natifs de Python sont assez limités pour les manipuler correctement.

Considérons par exemple la liste suivante, représentant le revenu mensuel de cinq clients de notre banque :

revenus = [1800, 1500, 2200, 3000, 2172]

Si on souhaite calculer la moyenne, il n’y a pas de fonction existante par défaut permettant de le faire : il faudrait la recoder soi-même ! C’est encore plus compliqué si on souhaite avoir une information plus spécifique, comme la médiane.

C’est là que la librairie NumPy intervient ! 

Diminutif de Numerical Python, elle fournit un ensemble de fonctions pour effectuer efficacement des opérations sur les données, mais propose également un objet qui est au cœur de presque tout l’écosystème data en Python : l’array.

Je vous propose dans ce chapitre de découvrir un peu plus en détail cette librairie, et pourquoi elle est aussi réputée dans l’environnement data Python aujourd’hui !

Différenciez les arrays des listes classiques

Les arrays NumPy

Le tableau NumPy, ou array, en anglais, est d’une certaine manière similaire à une liste Python. Son avantage ? Il permet d’effectuer simplement et rapidement de nombreuses opérations complexes, en plus de faciliter le stockage et la manipulation des données.

Reprenons notre exemple de calcul de la moyenne présenté ci-dessus. Dans les faits, la fonction n’est pas très complexe. Elle pourrait s’écrire :

def moyenne(liste):
    return sum(liste)/len(liste)
moyenne(revenus) # => 2134.4

Mais NumPy donne directement accès à une fonction existante.

Dans un premier temps, importons la librairie NumPy dans notre Notebook :

import numpy as np

Calculons à présent la moyenne :

np.mean(revenus)

C’est tout à fait logique, car la vraie révolution vient avec les arrays NumPy ! On estime qu’à mesure que la taille du tableau augmente, des opérations via array NumPy deviennent environ 30 fois plus rapides que via une liste Python classique. 

Cette différence aussi importante s’explique par le fait que les arrays NumPy ne peuvent contenir qu’un seul et même type. En effet, contrairement à une liste classique où l’on peut stocker tous types d’objets, NumPy n’acceptera qu’un seul type en entrée.

De plus, NumPy donne également accès à de nombreuses autres fonctions mathématiques indispensables, applicables à des arrays ou même à des listes :

x = [-2, -1, 1, 2]
print("La valeur absolue: ", np.abs(x))
print("Exponentielle: ", np.exp(x))
print("Logarithme: ", np.log(np.abs(x)))

Il en existe encore de nombreuses autres, que je vous invite à découvrir dans la documentation de NumPy. Je vous propose à présent de créer notre premier array. 

Créez un array NumPy

Vous pouvez faire cela de différentes façons, mais la plus simple est de le faire… à partir d’une liste Python classique :

revenus_array = np.array(revenus)
revenus_array
# array([1800, 1500, 2200, 3000, 2172])

Il existe également des fonctions NumPy permettant de créer des arrays selon un certain pattern ou une spécification particulière. Les plus couramment utilisées sont :

• np.zeros(n): permet de créer un array rempli de 0, de n éléments ;

• np.ones(n) : similaire en tous points à la fonction présentée ci-dessus, à la différence que l’array sera rempli cette fois-ci de 1 ;

• np.arange(i, j, p)  : permet de créer un array rempli avec une séquence linéaire, qui ira de  i  à  j, par pas de  p  ;

• np.linspace(i, j, n) : permet de créer un array de  n  valeurs espacées uniformément entre  i  et  j.

Créez un array monotype

Comme nous avons pu le voir précédemment, un array ne peut contenir qu’un seul et unique type. Vous pouvez accéder au type des éléments d’un array via la méthode  .dtype  :

revenus_array.dtype
# dtype('int32')

Pour plus d'informations sur les types NumPy, consultez la page Data types de la documentation officielle.

Voyons à présent comment sélectionner des éléments au sein d’un array NumPy.

Sélectionnez des éléments au sein d’un array

Qu'en est-il de l’accès aux différents éléments d’un array ? Tout comme avec une liste classique, vous pouvez faire cela via l’indice de ces derniers.

Accédez à un seul élément

L’accès à un élément spécifique d’un array se fait via la syntaxe :  nom_array[indice]  :

# pour accéder au 5ème élement
revenus_array[4] 

# pour accéder au dernier élément
revenus_array[-1]

# On peut aussi modifier les valeurs
revenus_array[1] = 1900

Accédez à plusieurs éléments contigus

Nous pouvons accéder à un ensemble d'éléments contigus en combinant []  et  : . La syntaxe suit une règle simple : nom_array[i:j:p] , avec :

•  i  : l’indice du début ;

•  j  : l’indice de fin ;

• p : le pas.

permettant de sélectionner tous les éléments compris entre l’indice  i  inclus, jusqu’à  j-1   – l’élément d’indice  j  est forcément exclu. La ligne :

revenus_array[0:3]

permet de sélectionner, au sein de notre array  revenus_array , l’ensemble des éléments de l’indice 0 (soit le premier élément) jusqu’à celui d’indice 2 (soit le troisième). L’élément d’indice 3 n’est pas inclus ! Si vous souhaitez également le sélectionner, il faudra ajouter 1 à l’indice de fin : revenus_array[0:4] .

# Les 3 premiers éléments
print(revenus_array[:3])

# Les éléments à partir de l’indice 2
print(revenus_array[2:])

# Un élément sur deux
print(revenus_array[::2])

Si le pas est négatif, le début et la fin du slice sont inversés. On peut utiliser cette propriété pour inverser un tableau.

revenus_array[::-1]

Accédez à plusieurs éléments selon une condition

On peut cependant souhaiter aller plus loin dans l’accès aux différents éléments. En effet, lors d’une étude de données on est régulièrement amené à devoir sélectionner une partie de nos données, selon un critère (ex. un genre spécifique) ou une condition (ex. toutes les personnes en dessous d’un certain âge). Les arrays NumPy permettent de faire cela !

En effet, de la même façon qu’il est possible de sélectionner des éléments via leur indice, il est possible avec les arrays NumPy de renseigner la condition selon laquelle on souhaite sélectionner les éléments du tableau, avec l’écriture  nom_array[condition de sélection]  .

Voilà par exemple comment sélectionner uniquement les valeurs supérieures à 2 000 € :

revenus_array[revenus_array > 2000]
# array([2200, 3000, 2172])

Détaillons le fonctionnement de ce processus de sélection :

• tout d’abord, on cite explicitement le nom de l’array avant les crochets, pour spécifier dans quel array on souhaite effectuer la sélection ;

• ensuite, on spécifie à l’intérieur des crochets la condition. Le résultat de ce qui est à l’intérieur des crochets doit forcément être un array ou une liste de booléens ! Ici, si on exécute uniquement la condition  revenus_array > 2000 , vous verrez que vous aurez simplement un array contenant uniquement des booléens, avec True  lorsque la valeur satisfait la condition, False  sinon.

Il est naturellement possible de complexifier cela, avec plusieurs conditions :

revenus_array[(revenus_array > 2000) & (revenus_array < 3000)]
# array([2200, 2172])

Il est à noter que cette syntaxe ne permet pas uniquement de sélectionner des éléments, mais qu'elle peut également être utilisée pour modifier des éléments au sein d’un array. En effet, si vous exécutez :

• revenus_array[3] = 1790 , cela signifie que vous remplacez le 4e élément de notre array par 1 790 ;

• revenus_array[revenus_array > 2000] = 0 , vous remplacerez tous les éléments supérieurs à 2 000 au sein de notre array par 0. Il faut donc être vigilant en utilisant cette syntaxe, pour ne pas remplacer des valeurs qu’il n’aurait pas été souhaitable de remplacer.

Je vous propose à présent de découvrir quelques-unes des nombreuses méthodes applicables à des arrays.

Utilisez les méthodes d’array

Nous avons d’ores et déjà vu comment obtenir le type d’un array à partir de la méthode  .dtype  . De la même façon, on peut accéder facilement aux dimensions de notre array via la méthode  .shape : 

revenus_array.shape
# (5,) on a array contenant 5 éléments

Le résultat nous indique qu’on a un array contenant 5 éléments (nous verrons ultérieurement la raison de la virgule après le 5).

On peut également appliquer de nombreuses opérations mathématiques très simplement :

# calculer la moyenne
revenus_array.mean()

# calculer le maximum (ou le minimum) :
revenus_array.max()
revenus_array.min()

# accéder à l’indice de l’élement minimum (ou maximum) :
revenus_array.argmin()
revenus_array.argmax()

# ordonner par ordre croissant :
revenus_array.sort()
print(revenus_array)

# calculer la somme :
revenus_array.sum()

Cette liste est naturellement non exhaustive ! Vous pouvez trouver la liste de l’ensemble des méthodes applicables à un array directement dans la documentation officielle. 

À vous de jouer

Contexte

Tout au long de ce cours, vous allez vous mettre dans la peau d’une personne travaillant  dans un service data au sein d'une banque. Plus précisément, vous travaillez pour la filière gérant les différents prêts. L’objectif sera d’utiliser les connaissances acquises sur les librairies Python pour aider l’agence dans différentes tâches.

Pour ce faire, vous pourrez pratiquer directement au travers des notebooks Google Colaboratory créés pour l’occasion. 

Consignes

Pour cette première tâche, nous avons à notre disposition les revenus de 10 clients de notre banque. Vous aurez à utiliser les différentes manipulations présentées dans ce chapitre pour sélectionner certains revenus selon une condition spécifique, et effectuer diverses opérations.

Je vous invite à suivre ce lien pour retrouver l'énoncé de l'exercice. 

Vérifiez votre travail

Une fois ce dernier fini, vous pourrez vérifier votre travail avec la correction.

En résumé

• NumPy (pour Numerical Python) est une librairie Python permettant de manipuler et d’effectuer rapidement et simplement de nombreuses opérations mathématiques sur un tableau de données.

• Les données sont stockées dans une structure similaire à une liste Python, un tableau NumPy, ou array.

• Ce dernier, contrairement à une liste, est obligatoirement monotype.

• On peut sélectionner au sein d’un array :

  • un élément via son indice avec l’écriture :  nom_array[indice]  ;

  • plusieurs éléments contigus via la syntaxe :  nom_array[début:fin:pas]  ;

  • certains éléments spécifiques via une condition :  nom_array[condition]  .

• Les arrays possèdent de nombreuses méthodes permettant de les manipuler ou d'effectuer des opérations mathématiques, de façon très simple.

Plongeons à présent un peu plus profondément dans la manipulation de données avec NumPy, notamment avec la manipulation de tableaux à plus d’une dimension !