Iloc vs Loc dans Pandas : Un guide avec des exemples

L'une de ces choses ennuyeuses que nous essayons tous de comprendre lorsque nous apprenons Pandas est la distinction entre .loc et .iloc.

Mettons fin à cette confusion et clarifions la différence entre ces deux méthodes. Je donnerai de nombreux exemples et j'espère que la distinction sera beaucoup plus claire à la fin de ce blog.

Que sont .loc et .iloc dans Pandas ?

.loc et .iloc sont des attributs essentiels des DataFrame Pandas, et sont tous deux utilisés pour sélectionner des sous-ensembles spécifiques de données. Leur objectif est d'accéder à une partie spécifique du DataFrame et de permettre sa manipulation au lieu de l'ensemble du DataFrame. 

Comme le montre le tableau , la syntaxe est très similaire. La différence réside dans la manière dont nous utilisons les arguments row_indexer et column_indexer. En effet, les deux méthodes proposent des approches différentes pour l'indexation des données : alors que .loc indexe sur la base des noms d'étiquettes, .iloc prend comme argument l'indice de position numérique des lignes et des colonnes.

Examinons chacune des deux méthodes en détail, en commençant par .loc.

Utilisation de .loc : Sélection par étiquettes

Pour illustrer ces concepts, considérons une base de données clients hypothétique représentée par ce DataFrame appelé df, le Customer ID représentant l'index de la ligne :

Il existe quatre façons principales de sélectionner des lignes avec .loc. Il s'agit notamment de

• Sélection d'une seule ligne
• Sélection de plusieurs lignes
• Sélection d'une tranche de lignes
• Sélection conditionnelle des lignes

Sélection d'une seule ligne à l'aide de .loc

Pour sélectionner une seule ligne, nous utilisons l'étiquette de la ligne que nous voulons récupérer comme row_indexer. La syntaxe est donc la suivante : df.loc['row_label']. Utilisons-le pour afficher toutes les informations sur notre client Ali Khan :

df.loc['C345']

Sélection de plusieurs lignes à l'aide de .loc

Si nous voulons sélectionner plusieurs lignes qui ne se suivent pas nécessairement dans l'ordre, nous devons transmettre une liste d'étiquettes de lignes en tant qu'argument row_indexer. Cela signifie que nous devons utiliser non pas une, mais deux paires de crochets : une pour la syntaxe normale de .loc et une pour la liste d'étiquettes.

La ligne df.loc[['row_label_1', 'row_label_2']] renvoie les deux lignes du DataFrame df spécifié dans la liste. Supposons que nous voulions non seulement des informations sur Ali Khan, mais aussi sur David Lee :

df.loc[['C345', 'C567']]

Sélection d'une tranche de lignes à l'aide de .loc

Nous pouvons sélectionner une série de lignes en passant les étiquettes de la première et de la dernière ligne, séparées par deux points : df.loc['row_label_start':'row_label_end']. Nous pourrions afficher les quatre premières lignes de notre DataFrame comme suit :

df.loc['C123' : 'C456']

Il y a deux choses à garder à l'esprit :

1. La sortie comprend la ligne spécifiée dans row_label_end. Il en va différemment sur le site .iloc, que nous aborderons plus loin.
2. Nous n'utilisons qu'une seule paire de crochets, même si nous voulons récupérer plusieurs lignes. Nous n'utilisons pas de liste pour spécifier les différentes lignes, de sorte que l'utilisation de deux crochets renverrait une adresse SyntaxError.

Sélection conditionnelle de lignes à l'aide de .loc

Nous pouvons également renvoyer des lignes sur la base d'une expression conditionnelle. Nous pouvons filtrer toutes les lignes selon qu'elles remplissent ou non une certaine condition et n'afficher que celles qui remplissent cette condition.

La syntaxe correspondante est df.loc[conditional_expression], conditional_expression étant une déclaration concernant les valeurs autorisées dans une colonne spécifique.

Pour les colonnes contenant des données non numériques (comme Name ou Country), la déclaration ne peut utiliser que l'opérateur égal ou inégal, car il n'y a pas d'ordre entre les valeurs. Nous pourrions, par exemple, renvoyer toutes les lignes de clients qui ne sont pas originaires d'Asie :

df.loc[df['Region'] != 'Asia']

Sélection d'une seule colonne à l'aide de .loc

Pour sélectionner des colonnes, nous devons spécifier l'argument column_indexer, qui vient après l'argument row_indexer. Si nous voulons spécifier uniquement le site column_indexer, nous devons indiquer d'une manière ou d'une autre que nous voulons renvoyer toutes les lignes et filtrer uniquement sur les colonnes. Voyons comment nous pouvons y parvenir !

La sélection d'une seule colonne peut se faire en spécifiant l'adresse column_indexeravec l'étiquette de la colonne concernée. Pour récupérer toutes les lignes, nous devons spécifier l'adresse row_indexer avec un simple deux-points. Nous arrivons à une syntaxe qui ressemble à ceci : df.loc[:, 'column_name'].

Affichons le site Name de chaque client :

df.loc[:, 'Name']

Sélection de plusieurs colonnes à l'aide de .loc

Comme pour la sélection de plusieurs lignes, nous devons transmettre une liste d'étiquettes de colonnes si nous voulons retourner plusieurs colonnes d'un DataFrame qui ne se suivent pas nécessairement dans l'ordre : df.loc[:, [col_label_1, 'col_label_2']].

En supposant que nous voulions ajouter l'adresse Age de tous les clients à notre dernier résultat, cela fonctionnerait comme suit :

df.loc[:, ['Name', 'Age']]

Sélection d'une tranche de colonnes à l'aide de .loc

L'utilisation de deux points entre les étiquettes de deux colonnes permet de sélectionner toutes les colonnes de la plage d'ordre entre les deux colonnes spécifiées. Elle inclut la colonne de fin, ce qui signifie que la colonne nommée col_end sera également sélectionnée dans la syntaxe standard, qui est la suivante : df.loc[:, 'col_start':'col_end'].

Si nous nous intéressons aux Name, Country et Region de nos clients, notre ligne de code pourrait être la suivante :

df.loc[:, 'Name':'Region']

Sélection combinée de lignes et de colonnes à l'aide de .loc

Il est également possible de spécifier à la fois le row_indexer et le column_indexer. Cette fonction peut être utilisée pour récupérer un seul élément d'information, c'est-à-dire une cellule du DataFrame. Pour ce faire, nous spécifions une ligne et une colonne à l'aide de la syntaxe suivante : df.loc['row_label', 'column_name'] .

Le cas le plus utile est de renvoyer un sous-DataFrame qui se concentre exactement sur l'ensemble des lignes et des colonnes qui nous intéressent. Il est possible de spécifier les deux indexeurs sous forme de liste en utilisant les crochets, ou sous forme de tranche en utilisant les deux points, et même de les combiner avec une expression conditionnelle pour la sélection des lignes.

Voici un exemple de renvoi des adresses Name, Country et Region de chaque client dont l'adresse Age est supérieure à 30 :

df.loc[df['Age'] > 30, 'Name':'Region']

Utilisation de .iloc : Sélection par position de l'entier

.iloc sélectionne par la position au lieu de l'étiquette. Il s'agit de la syntaxe standard d'utilisation de .iloc: df.iloc[row_indexer, column_indexer]. Il y a deux choses particulières auxquelles il faut faire attention :

• Comptage à partir de 0 : La première ligne et la première colonne ont l'indice 0, la deuxième l'indice 1, etc.
• Exclusivité de la valeur de fin de gamme : Lorsque vous utilisez une tranche, la ligne ou la colonne spécifiée derrière les deux points n'est pas incluse dans la sélection.

Sélection d'une seule ligne à l'aide de .iloc

Une seule ligne peut être sélectionnée en utilisant l'entier représentant le numéro d'index de la ligne comme row_indexer. Nous n'avons pas besoin de guillemets puisque nous entrons un nombre entier et non une chaîne d'étiquettes comme nous l'avons fait avec .loc. Pour renvoyer la première ligne d'un DataFrame appelé df, entrez df.iloc[0].

Dans notre exemple DataFrame, cette même ligne de code renvoie les informations relatives à John Doe :

df.iloc[0]

Sélection de plusieurs lignes à l'aide de .iloc

La sélection de plusieurs lignes fonctionne dans .iloc comme dans .loc- nous entrons les entiers d'index de ligne dans une liste avec des crochets. La syntaxe est la suivante : df.iloc[[0, 3, 4]].

Vous trouverez ci-dessous les résultats respectifs dans notre tableau client :

df.iloc[[0, 3, 4]]

Sélection d'une tranche de lignes à l'aide de .iloc

Pour sélectionner une tranche de lignes, nous utilisons deux points entre deux entiers d'index de ligne spécifiés. Il faut maintenant tenir compte de l'exclusivité mentionnée plus haut. 

Nous pouvons prendre l'exemple de la ligne df.iloc[1:4] pour illustrer ce concept. Le numéro d'index 1 correspond à la deuxième ligne, notre tranche commence donc à cet endroit. L'entier d'indexation 4 représente la cinquième ligne - mais comme .iloc n'est pas inclusif pour la sélection des tranches, notre sortie inclura toutes les lignes jusqu'à la dernière avant celle-ci. Par conséquent, il renverra la deuxième, la troisième et la quatrième ligne. 

Prouvons que la ligne fonctionne comme elle le devrait :

df.iloc[1:4]

Sélection d'une seule colonne à l'aide de .iloc

La logique de sélection des colonnes à l'aide de .iloc est conforme à ce que nous avons appris jusqu'à présent. Voyons comment cela fonctionne pour les colonnes simples, les colonnes multiples et les tranches de colonnes.

Tout comme pour .loc, il est important de spécifier row_indexer avant de pouvoir passer à column_indexer. Pour récupérer les valeurs de la troisième colonne de df pour chaque ligne, nous entrons df.iloc[:, 2].

Comme Region est la troisième colonne de notre DataFrame, elle sera récupérée en conséquence de cette ligne de code :

df.iloc[:, 2]

Sélection de plusieurs colonnes à l'aide de .iloc

Pour sélectionner plusieurs colonnes qui ne se suivent pas nécessairement, nous pouvons à nouveau saisir une liste contenant des nombres entiers comme column_indexer. La ligne df.iloc[:, [0, 3]] renvoie les première et quatrième colonnes. 

Dans notre cas, les informations affichées sont le Name ainsi que le Age de chaque client :

df.iloc[:, [0, 3]]

Sélection d'une tranche de colonnes à l'aide de .iloc

Pour la sélection des tranches à l'aide de .iloc, la logique de column_indexer suit celle de row_indexer. La colonne représentée par l'entier après les deux points n'est pas incluse dans la sortie. Pour récupérer les deuxième et troisième colonnes, la ligne de code doit ressembler à ceci : df.iloc[:, 1:3].

La ligne ci-dessous renvoie toutes les informations géographiques dont nous disposons sur nos clients :

df.iloc[:, 1:3]

Sélection combinée de lignes et de colonnes à l'aide de .iloc

Nous pouvons mettre en commun ce que nous avons appris sur .iloc pour combiner la sélection des lignes et des colonnes. Là encore, il est possible de renvoyer une seule cellule ou un sous-DataFrame. Pour retourner la cellule unique à l'intersection de la ligne 3 et de la colonne 4, nous entrons df.iloc[2, 3].

Comme pour .loc, nous pouvons spécifier les deux indexeurs sous forme de liste en utilisant les crochets, ou sous forme de tranche en utilisant les deux points. Si nous voulons sélectionner des lignes à l'aide d'expressions conditionnelles, c'est techniquement possible avec .iloc également, mais ce n'est pas recommandé. L'utilisation des noms d'étiquettes et de .loc est généralement beaucoup plus intuitive et moins sujette aux erreurs.

Ce dernier exemple affiche Country, Region et Age pour la première, la deuxième et la cinquième ligne de notre DataFrame :

df.iloc[[0,1,4], 1:4]

.iloc vs .loc : Quand utiliser Which

En général, il existe une règle simple selon laquelle le choix de la méthode dépend de votre connaissance du DataFrame :

• Utiliser .loc lorsque vous connaissez les étiquettes (noms) des lignes/colonnes.
• Utilisez .iloc lorsque vous connaissez les positions entières des lignes/colonnes.

Certains scénarios favorisent par nature .loc ou .iloc. Par exemple, il est plus facile et plus intuitif d'itérer sur des lignes ou des colonnes en utilisant des nombres entiers plutôt que des étiquettes. Comme nous l'avons déjà mentionné, le filtrage des lignes basé sur des conditions relatives aux valeurs des colonnes est moins sujet aux erreurs si l'on utilise les noms des étiquettes des colonnes.

Erreur de clé, erreur de nom et erreur d'index avec .loc et .iloc

Examinons les problèmes possibles. Un écueil fréquent lors de l'utilisation de .loc est la rencontre d'un KeyError. Cette erreur se produit lorsque nous essayons d'accéder à une étiquette de ligne ou de colonne qui n'existe pas dans notre DataFrame. Pour éviter cela, nous devons toujours nous assurer que les étiquettes que nous utilisons sont exactes et qu'elles correspondent aux étiquettes existantes dans votre DataFrame et vérifier deux fois qu'il n'y a pas de fautes de frappe.

En outre, il est important de toujours utiliser des guillemets pour les étiquettes spécifiées à l'aide de .loc. En les oubliant, vous obtiendrez un NameError.

Une erreur IndexError peut se produire lors de l'utilisation de .iloc si nous spécifions une position entière qui est en dehors de la plage valide des indices de notre DataFrame. Cela se produit lorsque l'index auquel vous essayez d'accéder n'existe pas, soit parce qu'il dépasse le nombre de lignes ou de colonnes de votre DataFrame, soit parce qu'il s'agit d'une valeur négative. Pour éviter cette erreur, vérifiez les dimensions de votre DataFrame et utilisez des valeurs d'index appropriées dans la plage valide.

Conclusion

J'espère que ce blog a été utile et que la distinction entre .loc et .iloc est maintenant claire. Pour en savoir plus, voici quelques bonnes étapes à suivre :

• SettingWithCopyWarning dans Pandas : Comment corriger cet avertissement
• Cours : Manipulation de données avec pandas
• Cours : Écrire du code efficace avec pandas
• Aide-mémoire : Manipulation de données avec pandas
• Aide-mémoire : Remodeler les données avec pandas