La Data Science étant un domaine très vaste, il est impossible de maîtriser tous les langages et toutes les bibliothèques – et même après avoir travaillé 10 ans dans ce domaine, mes connaissances sont limitées. L’apprentissage constant c’est ce qui me maintient dans le game, et après réflexion, connaître les fonctions de cet article aurait été un énorme gain de temps dès le début. Alors si je peux te faire gagner ce temps précieux, j’en serai ravi !

Certaines d’entre elles sont purement fonctionnelles, mais d’autres, en revanche, font référence à la façon dont on utilise Pandas, et la raison pour laquelle une approche est meilleure qu’une autre.

Commençons donc par la première – elle pourrait te surprendre par son efficacité.

itertuples()

Euh…attends, quoi ? Oui, il ne s’agit pas d’une fonction à proprement parler, mais de la manière la plus efficace d’utiliser Pandas, c’est-à-dire la manière la plus rapide d’itérer à travers un ensemble de données.

Alors, je sais qu’il y a des moyens plus efficaces pour additionner les valeurs des colonnes, mais je le fais de cette façon juste pour faire valoir mon point de vue.

Nous allons déclarer un jeu de données simple avec une seule colonne, contenant une plage de nombres de 1 à 1 million. Voici comment procéder :

df = pd.DataFrame(data={'Nombre': range(1, 1000000)})

Voici à quoi ressemblent les 5 premières lignes :

Maintenant, faisons les choses de la mauvaise manière. Nous allons déclarer une variable total et la fixer à 0. Ensuite, en utilisant iterrows(), nous allons itérer sur l’ensemble de données et incrémenter le résultat de la variable total de la valeur de la ligne actuelle. Nous allons également mesurer la durée d’exécution (sur Google Colab).
Voici le code :

%%time
total = 0
for _, row in df.iterrows():
    total += row['Nombre']
 
total

>>> Wall time: 41.1 s

Plus de 41 secondes pour cette opération triviale – mais il y a une meilleure façon de procéder. Faisons la même chose, mais avec iteruples au lieu de iterrows :

%%time
total = 0
for row in df.itertuples(index=False):
    total += row.Nombre
 
total

>>> Wall time: 533 ms

Je ne ferai pas les calculs, mais l’amélioration de la vitesse est significative. Ne l’oublie pas la prochaine fois que tu exécuteras une boucle !

nlargest() et nsmallest()

Hier encore, je calculais une distance en kilomètres à partir de deux paires latitude/longitude. C’était la première partie du problème – la seconde consistait à sélectionner les N premiers enregistrements avec la plus petite distance.

C’est là qu’intervient la fonction nsmallest().

Comme son nom l’indique, nlargest() renvoie les N plus grandes valeurs, et nsmallest() fait exactement l’inverse.

Voyons cela en action. Pour la partie pratique, j’ai préparé un petit ensemble de données :

df = pd.DataFrame(data={
    'Nom': ['Bob', 'Marc', 'Jon', 'Anna', 'Elio', 'Dexter'],
    'Points': [37, 91, 66, 42, 99, 81]
})

Et voici à quoi cela ressemble :

Supposons maintenant que cet ensemble de données ne contienne plus 6 lignes mais 6000, et que l’on souhaite déterminer quels sont les élèves qui ont obtenu les meilleurs résultats, c’est-à-dire qui ont obtenu le plus grand nombre de points. Une façon de procéder serait la suivante :

df['Points'].nlargest(3)

Cette solution n’est pas optimale, car elle aboutirait à ce résultat :

4    99
1    91
5    81
Name: Points, dtype: int64

Ce n’est pas une bonne chose car tu n’as pas une image claire des noms réels. Voici comment améliorer la solution :

df.nlargest(3, columns='Points')

Maintenant, les résultats sont beaucoup plus satisfaisants :

Tu peux mettre en œuvre presque la même logique pour trouver les 3 élèves qui ont obtenu les moins bons résultats – avec la fonction nsmallest() :

df.nsmallest(3, columns='Points')

Voici le résultat :

Passons maintenant à la dernière fonction.

cut()

Pour démontrer les capacités de cette fonction, nous utiliserons l’ensemble de données de la section précédente.

L’idée de base de la fonction cut() est de diviser les valeurs en intervalles discrets. Voici l’exemple le plus simple : nous allons créer deux intervalles à partir de l’attribut Points :

pd.cut(df['Points'], bins=2)

0    (36.938, 68.0]
1      (68.0, 99.0]
2    (36.938, 68.0]
3    (36.938, 68.0]
4      (68.0, 99.0]
5      (68.0, 99.0]
Name: Points, dtype: category
Categories (2, interval[float64, right]): [(36.938, 68.0] < (68.0, 99.0]]

Ce n’est pas très utile pour l’instant. Mais pourquoi ne pas déclarer que le premier intervalle va de 0 à 50, et le second de 50 à 100 ? Cela semble être un bon plan.
Voici le code :

pd.cut(df['Points'], bins=[0, 50, 100])

0      (0, 50]
1    (50, 100]
2    (50, 100]
3      (0, 50]
4    (50, 100]
5    (50, 100]
Name: Points, dtype: category
Categories (2, interval[int64, right]): [(0, 50] < (50, 100]]

Mais imaginons que vous souhaitiez afficher Échec au lieu de (0, 50) et Réussite au lieu de (50, 100).
Voici comment procéder :

pd.cut(df['Points'], bins=[0, 50, 100], labels=['Échec', 'Réusite'])

0      Échec
1    Réusite
2    Réusite
3      Échec
4    Réusite
5    Réusite
Name: Points, dtype: category
Categories (2, object): ['Échec' < 'Réusite']

Maintenant, ça ressemble à quelque chose !!

Avant de se quitter…

Si tu débutes en Python, ces fonctions t’aideront à gagner du temps. Si tu n’es plus débutant, la lecture de cet article t’aidera à renforcer la connaissance (de l’existence) de ces fonctions – parce qu’il est facile de les oublier et d’écrire la logique à partir de zéro (ce qui ne sert à rien).

J’espère que l’article t’a plu. Merci de ta lecture 🙂