5 Tips to Write Idiomatic Pandas Code

Bien sûr, ce tutoriel n’est pas exhaustif ; le package Pandas est très riche et il existe sans doute bien d’autres façons de rendre votre code plus idiomatique.

Allons droit au but et commençons !

# If you're working with a notebook, don't forget to use Matplotlib magic! 
%matplotlib inline

# Import pandas under the alias pd import pandas as pd # Import seaborn under the alias sns import seaborn as sns # Set the Seaborn theme if desired sns.set_style('darkgrid')

# Import Times Higher Education World University Rankings data
times_df = pd.read_csv('data/timesData.csv', thousands=",")

# Import Academic Ranking of World Universities data
shanghai_df = pd.read_csv('data/shanghaiData.csv')

Nos conseils pour un code Pandas idiomatique

1. Indexation

Écrire du code Pandas idiomatique, c’est d’abord exploiter la puissance de l’indexation, c’est‑à‑dire sélectionner des sous‑ensembles de votre DataFrame.

Au début, il faut un temps d’adaptation. Si vous avez déjà travaillé avec des listes Python, vous connaissez sans doute les crochets [] combinés aux deux‑points : pour sélectionner des éléments. Cette méthode fonctionne aussi sur les DataFrames.

Deux approches plus idiomatiques existent pour sélectionner un sous‑DataFrame : iloc et loc :

• loc est basé sur les étiquettes : si vous écrivez loc[2], vous cherchez les valeurs dont l’index est étiqueté 2.
• iloc est basé sur la position : si vous écrivez iloc[2], vous récupérez les valeurs situées à la position 2.

Testez ci‑dessous en saisissant times_df.loc[2] et times_df.iloc[2] dans la console IPython pour constater la différence. Ensuite, résolvez l’exercice à l’aide de loc, iloc et des crochets traditionnels !

Bien sûr, l’exploration ne se limite pas à sélectionner des lignes et des colonnes. Les choses deviennent intéressantes quand vous combinez loc et iloc avec, par exemple, des tableaux booléens.

On dépasse alors la simple sélection : c’est presque comme interroger vos données !

loc et iloc sont excellents pour indexer, mais attention si vous enchaînez deux paires de crochets ! Pandas peut renvoyer une copie d’une vue et vous pourriez ne plus savoir sur quel objet vous travaillez. Réfléchissez à deux fois avant d’utiliser deux crochets avec loc ou iloc.

Remarque : pour interroger vos données, Pandas propose aussi la fonction query() (disponible depuis la version 0.13), utile pour des inspections rapides. Par exemple, composez une requête pour voir quelles universités ont un total_score juste en dessous de 50 :

Les possibilités sont nombreuses ! Pourquoi ne pas tester des requêtes qui renvoient les universités classées premières au niveau national, puis mondial ? Vous pouvez aussi interroger les nombres d’alumni.

Besoin d’inspiration pour composer vos requêtes ? Voici quelques exemples :

shanghai_df.query("national_rank == 1 and world_rank == 1")
shanghai_df.query("alumni < 20")

2. Enchaînement de méthodes

L’enchaînement de méthodes est typique de Pandas, mais lorsqu’on débute, ce n’est pas toujours intuitif. Il s’agit simplement d’appeler plusieurs méthodes à la suite sur un même objet.

Dans cette section, vous irez plus loin en créant des pipelines de données avec pipe().

Vous l’avez remarqué : les jeux de données diffèrent. Par exemple :

• Times comporte 14 colonnes, Shanghai 11 ;
• Times contient 2603 lignes, Shanghai 4897 ;
• La colonne « pays » manque dans Shanghai. Vous pourrez l’extraire depuis Times si besoin.

Pour utiliser les deux DataFrames, ne gardons que les colonnes communes — en espérant qu’elles contiennent des informations similaires.

Les colonnes communes sont donc :

• total_score : score utilisé pour déterminer le rang. Comme précisé sur Kaggle, il peut s’agir de plages (entre deux valeurs) ou d’égalités (préfixées par =).
• university_name : nom de l’université.
• world_rank : rang mondial de l’université.
• year : année du classement.

Avant de concaténer les deux jeux, effectuons un peu de nettoyage. Appliquez maintenant le pipeline complet pour nettoyer les données :

Vous remarquerez que j’utilise souvent la méthode .pipe dans ce tutoriel. Si vous venez de R, cela vous semblera familier.

C’est une méthode pratique (depuis la version 0.16.2) qui permet d’enchaîner les opérations et d’éviter les DataFrames intermédiaires. Votre code gagne en lisibilité.

Sans cet opérateur, au lieu d’écrire df.pipe(f).pipe(g).pipe(h), vous écririez h(g(f(df))) — vite illisible avec des imbrications profondes.

Pour approfondir, je vous recommande vivement cet article de blog.

Maintenant que les deux DataFrames sont nettoyés, nous pouvons les concaténer en un seul. N’oubliez pas de gérer les valeurs manquantes :

Environ 38 % des valeurs de la colonne total_score sont manquantes : mieux vaut supprimer cette colonne avec .drop.

3. Optimisation mémoire

Troisième levier pour rendre votre code Pandas plus « idiomatique » — et surtout plus performant : optimiser l’usage mémoire. Avec des pipelines enchaînés, la mémoire influe fortement sur la vitesse d’exécution. Voyons cela.

Sur un petit jeu comme celui‑ci c’est peut‑être excessif, mais caster certaines colonnes vers des types spécifiques est souvent une bonne pratique. Commencez par mesurer la mémoire allouée à ranking_df avec .info.

Le premier appel indique 144 Ko. En regardant les arguments de .info, on découvre memory_usage, optionnel (None par défaut). Que se passe‑t‑il si vous le passez à deep ?

L’empreinte mémoire devient environ 5,6 fois plus grande que l’estimation initiale.

Pourquoi ?

Sans l’option « deep », Pandas n’estime pas la mémoire des colonnes de type object. Or ce type Python occupe plus d’espace que les dtypes optimisés de numpy. Il est donc recommandé de convertir les object vers des types plus adaptés (par exemple category pour des données catégorielles).

Faisons‑le !

def memory_change(input_df, column, dtype):
    df = input_df.copy()
    old = round(df[column].memory_usage(deep=True) / 1024, 2) # In KB
    new = round(df[column].astype(dtype).memory_usage(deep=True) / 1024, 2)# In KB
    change = round(100 * (old - new) / (old), 2)
    report = ("The inital memory footprint for {column} is: {old}KB.\n" 
              "The casted {column} now takes: {new}KB.\n"
              "A change of {change} %.").format(**locals())
    return report

print(memory_change(ranking_df,'world_rank', 'int16'))
print(memory_change(ranking_df,'university_name', 'category'))
print(memory_change(ranking_df,'name', 'category'))

Maintenant que vous savez qu’en passant world_rank en int16, par exemple, vous gagnez en efficacité mémoire, appliquez ces changements avec astype(). Terminez en vérifiant l’usage mémoire :

Beaucoup mieux. Vous pouvez aller plus loin en castant aussi la colonne year en int32.

4. GroupBy

Maintenant que le jeu est propre (données ordonnées) et l’empreinte mémoire optimisée, place à l’analyse.

Deux questions intéressantes :

• Quelles sont les 5 meilleures universités selon chaque système de classement au fil des années ?
• En quoi ces classements diffèrent‑ils chaque année ?

Répondons à la première, en appliquant les bonnes pratiques idiomatiques vues plus haut.

Avant de commencer, remarquez que « Massachusetts Institute of Technology (MIT) » et « Massachusetts Institute of Technology » désignent la même université avec deux enregistrements différents. Remplacez le premier par le second.

Dans ce type de cas, la fonction loc vue plus haut est particulièrement utile.

Pour trouver les 5 (meilleures) universités chaque année et pour chaque système, voici le pseudo‑code :

• Pour chaque année (year) et chaque système (name) :
• Sélectionner le sous‑ensemble correspondant
• Prendre les 5 premières et les stocker dans une liste
• Enregistrer le résultat dans un dictionnaire avec (year, name) comme clé et la liste (ordre décroissant) comme valeur

Appliquons‑le.

À partir de ce dictionnaire, mesurons en pourcentage à quel point les deux méthodes diffèrent au fil des ans : elles sont similaires à 100 % si les 5 universités sélectionnées sont les mêmes, quel que soit l’ordre.

Vous avez vu, c’est fastidieux. Existe‑t‑il une méthode Pandas plus idiomatique ?

Oui ! Commencez par filtrer le DataFrame pour ne garder que les 5 meilleures universités par année et par méthode. Vérifiez le résultat avec head() :

Avec ce DataFrame prêt, utilisez .groupby pour comparer les deux méthodes via la similarité d’ensemble définie plus haut.

Vous obtenez le même résultat, avec moins d’efforts.

5. Visualisation

Après ces premières analyses, place aussi à l’exploration visuelle. Écrire du code Pandas idiomatique, c’est profiter de son intégration graphique avec Matplotlib pour produire rapidement de beaux graphiques.

Dans cette section, revenez aux jeux times_df et shanghai_df pour réaliser quelques visualisations de base avec Matplotlib et Seaborn.

Ce nuage de points montre immédiatement des valeurs 0 dans la colonne alumni. À garder à l’esprit lors de l’exploration : grâce au data profiling, vous identifierez ces 0 et saurez les traiter. Pour en savoir plus, consultez le tutoriel sur le data profiling de DataCamp.

Si certaines valeurs n’ont pas leur place dans le jeu, remplacez‑les par NaN, puis supprimez les lignes NaN des colonnes qui compliquent la visualisation. Notez que c’est une correction rapide ; un profilage plus poussé sera souvent nécessaire. Vous verrez par exemple encore des 0 pour num_students dans le graphique ci‑dessous :

Vous n’êtes pas limité à Matplotlib. D’autres bibliothèques permettent aussi de visualiser rapidement, comme Seaborn.

Seaborn sert surtout à créer des graphiques statistiques esthétiques (comme indiqué sur le site officiel). Avant Matplotlib 2.0, produire de beaux graphiques était plus laborieux.

Combiné à Pandas, Seaborn permet d’itérer rapidement sur vos données via la visualisation.

Voyons quelques exemples !

Observez le graphique suivant : on y compte le nombre d’occurrences par pays, on ne garde que les dix premiers, puis on trace un diagramme en barres trié du plus élevé au plus faible :

Puis tracez ces pays avec leur score moyen :

Vos graphiques peuvent aussi devenir plus complexes. Par exemple, ce pairplot met en évidence les relations par paires dans un jeu de données :

import numpy as np

np.seterr(invalid='ignore')

sns.pairplot(times_df, hue='country')

plt.show()

De même, voici une combinaison de FacetGrid et regplot qui illustre l’évolution de total_score au fil des ans pour les 5 pays en tête :

Enfin, une carte de corrélations est souvent utile en exploration. Utilisez la fonction heatmap() de Seaborn :

Vous pouvez continuer avec ces visualisations, mais il est peut‑être temps de s’arrêter :)