Iloc vs Loc in Pandas: Un guide avec des exemples

L’un de ces éléments agaçants 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 vais donner de nombreux exemples, et j’espère que la distinction sera beaucoup plus claire à la fin de ce blog.

Qu’est-ce que .loc et .iloc dans Pandas?

À la fois .loc et .iloc sont des attributs essentiels des DataFrames Pandas, et les deux sont utilisés pour sélectionner des sous-ensembles spécifiques de données. Leur but est d’accéder et de permettre de manipuler une partie spécifique du DataFrame au lieu de l’ensemble du DataFrame.

Comme nous pouvons le voir dans 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. Cela est dû aux deux méthodes qui offrent des approches différentes pour indexer les données : tandis que .loc indexe en fonction des noms d’étiquettes, .iloc utilise les indices de position numériques des lignes et des colonnes comme arguments.

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

À l’aide de .loc : Sélection par libellés

Pour illustrer les concepts, considérons une base de données client hypothétique représentée par ce DataFrame appelé df, avec l’identifiant client représentant la ligne index :

There are four primary ways to select rows with .loc. These include:

• Selecting a single row
• Sélection de plusieurs lignes
• Sélection d’une tranche de lignes
• Sélection de lignes conditionnelle

Sélection d’une seule ligne en utilisant .loc

Pour sélectionner une seule ligne, nous utilisons le label de la ligne que nous voulons récupérer en tant que row_indexer. En conséquence, la syntaxe ressemble à ceci : df.loc['row_label']. Utilisons ceci pour afficher toutes les informations sur notre client Ali Khan :

df.loc['C345']

Sélection de plusieurs lignes en utilisant .loc

Si nous voulons sélectionner plusieurs lignes qui ne se suivent pas nécessairement dans l’ordre, nous devons passer une liste de leurs étiquettes de ligne en tant qu’argument row_indexer. Cela signifie que nous devons utiliser non pas un mais deux paires de crochets : une pour la syntaxe régulière de .loc et une pour la liste d’étiquettes.

La ligne df.loc[['row_label_1', 'row_label_2']] renverra les deux lignes du DataFrame df spécifiées dans la liste. Disons que nous voulions non seulement les 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 plage de lignes en passant les étiquettes de la première et de la dernière ligne avec un deux-points entre elles : df.loc['étiquette_de_début_de_ligne':'étiquette_de_fin_de_ligne']. Nous pourrions afficher les quatre premières lignes de notre DataFrame de cette manière :

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

Il y a deux choses à garder à l’esprit ici:

1. La sortie inclut la ligne spécifiée dans row_label_end. Cela est différent dans .iloc, que nous aborderons plus tard.
2. Nous n’utilisons qu’une 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, donc l’utilisation de deux crochets renverrait une SyntaxError.

Sélection conditionnelle des lignes en utilisant .loc

Nous pouvons également renvoyer des lignes en fonction d’une expression conditionnelle. Nous pouvons filtrer toutes les lignes en fonction de la réalisation ou non d’une certaine condition et n’afficher que celles qui le font.

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

Pour les colonnes avec des données non numériques (comme Nom ou Pays), l’instruction ne peut utiliser que l’opérateur d’égalité ou de non-égalité, car il n’y a pas d’ordre entre les valeurs. Par exemple, nous pourrions retourner toutes les lignes des clients qui ne sont pas originaires d’Asie :

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

Sélectionner une seule colonne en utilisant .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 column_indexer, nous devons d’une manière ou d’une autre indiquer que nous voulons renvoyer toutes les lignes et filtrer uniquement sur les colonnes. Voyons comment nous pouvons le faire!

La sélection d’une seule colonne peut être effectuée en spécifiant le column_indexer avec le libellé de la colonne respective. Pour récupérer toutes les lignes, nous devons spécifier le row_indexer avec un simple deux-points. Nous obtenons une syntaxe qui ressemble à ceci : df.loc[:, 'nom_de_la_colonne'].

Affichons le Nom de chaque client:

df.loc[:, 'Name']

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

De la même manière que pour la sélection de plusieurs lignes, nous devons passer une liste d’étiquettes de colonnes si nous voulons renvoyer plusieurs colonnes d’un DataFrame qui ne se suivent pas nécessairement dans l’ordre : df.loc[:, [col_label_1, 'col_label_2']].

Supposons que nous voulions ajouter l’âge de tous les clients à notre dernière sortie, cela fonctionnerait comme ceci :

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

Sélectionner une tranche de colonnes en utilisant .loc

En utilisant deux points entre les labels de deux colonnes, toutes les colonnes dans la plage d’ordre entre les deux colonnes spécifiées seront sélectionnées. Il est inclusif de 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 étions intéressés par le Nom, le Pays et la Région de nos clients, notre ligne de code pourrait être :

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

Sélection combinée de lignes et de colonnes en utilisant .loc

Il est également possible de spécifier à la fois le row_indexer et le column_indexer. Cela peut être utilisé pour récupérer une seule pièce d’information, c’est-à-dire une cellule du DataFrame. Pour ce faire, nous spécifions une ligne et une colonne en utilisant la syntaxe 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 listes en utilisant les crochets, ou sous forme de tranche en utilisant les deux-points, et même de le combiner avec une expression conditionnelle pour la sélection des lignes.

Voici un exemple de retour du Name, Country et Region de chaque client ayant un Age de plus de 30 :

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

En utilisant .iloc : Sélection par position entière

.iloc sélectionne par position au lieu de label. Voici la syntaxe standard d’utilisation de .iloc : df.iloc[row_indexer, column_indexer]. Il y a deux choses spéciales à prendre en compte :

• Comptage à partir de 0 : La première ligne et la première colonne ont l’indice 0, la deuxième a l’indice 1, etc.
• Exclusivité de la valeur de fin de l’intervalle : Lors de l’utilisation d’une plage, la ligne ou la colonne spécifiée après les deux-points n’est pas incluse dans la sélection.

Sélectionner une seule ligne en utilisant .iloc

Une seule ligne peut être sélectionnée en utilisant l’entier représentant le numéro d’indice de la ligne comme row_indexer. Nous n’avons pas besoin de guillemets car nous saisissons un nombre entier et non une chaîne de caractères d’étiquette comme nous l’avons fait avec .loc. Pour retourner la première ligne d’un DataFrame appelé df, saisissez df.iloc[0].

Dans notre exemple de DataFrame, cette ligne de code renvoie les informations de John Doe :

df.iloc[0]

Sélection de plusieurs lignes avec .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 ressemble à ceci : df.iloc[[0, 3, 4]].

La sortie respective dans notre tableau client peut être vue ci-dessous :

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

Sélectionner une tranche de lignes en utilisant .iloc

Pour sélectionner une tranche de lignes, nous utilisons un deux-points entre deux entiers d’index de ligne spécifiés. Maintenant, nous devons faire attention à l’exclusivité mentionnée précédemment. 

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

Prouvons que la ligne fonctionne comme elle devrait:

df.iloc[1:4]

Sélectionner une seule colonne à l’aide de .iloc

La logique de sélection des colonnes en utilisant .iloc suit 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 avec .loc, il est important de spécifier l’indexeur_de_ligne avant de pouvoir passer à l’indexeur_de_colonne. Pour récupérer les valeurs de la troisième colonne de df pour chaque ligne, nous saisissons df.iloc[:, 2].

Parce que Région 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électionner plusieurs colonnes en utilisant .iloc

Pour sélectionner plusieurs colonnes qui ne sont pas nécessairement consécutives, nous pouvons à nouveau entrer une liste contenant des entiers en tant que column_indexer. La ligne df.iloc[:, [0, 3]] renvoie à la fois la première et la quatrième colonnes. 

Dans notre cas, les informations affichées sont le Nom ainsi que l’Âge de chaque client :

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

Sélectionner une tranche de colonnes en utilisant .iloc

Pour la sélection de tranches en utilisant .iloc, la logique du column_indexer suit celle du 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 la deuxième et la troisième colonne, la ligne de code devrait ressembler à ceci : df.iloc[:, 1:3].

Cette ligne ci-dessous renvoie toutes les informations géographiques que nous avons sur nos clients :

df.iloc[:, 1:3]

Sélection combinée de lignes et de colonnes en utilisant .iloc

Nous pouvons mettre en pratique ce que nous avons appris sur .iloc pour combiner la sélection de lignes et de colonnes. Encore une fois, il est possible de retourner soit une seule cellule, soit un sous-DataFrame. Pour retourner la cellule unique à l’intersection de la ligne 3 et de la colonne 4, nous saisissons df.iloc[2, 3].

Tout comme avec .loc, nous pouvons spécifier les indexeurs sous forme de listes à l’aide des crochets, ou sous forme de plage à l’aide des 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é. Utiliser les noms d’étiquettes et .loc est généralement beaucoup plus intuitif et moins sujet aux erreurs.

Cet exemple final affiche Pays, Région et Âge pour la première, deuxième et cinquième ligne de notre DataFrame :

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

.iloc vs .loc: When to Use Which

Generally, there is one simple rule of thumb where the method choice depends on your knowledge of the DataFrame:

• Utilisez .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 soit .loc soit .iloc par leur nature. Par exemple, parcourir les lignes ou les colonnes est plus facile et plus intuitif en utilisant des entiers plutôt que des étiquettes. Comme nous l’avons déjà mentionné, filtrer les lignes en fonction des conditions sur les valeurs des colonnes est moins sujet aux erreurs en utilisant les noms des colonnes.

KeyError, NameError et Erreur d’indice avec .loc et .iloc

Jetons un coup d’œil aux problèmes possibles. Une erreur courante lors de l’utilisation de .loc est de rencontrer un KeyError. Cette erreur se produit lorsque nous tentons 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 les éventuelles fautes de frappe.

De plus, il est important d’utiliser toujours des guillemets pour les étiquettes spécifiées avec .loc. Oublier ces guillemets entraînera une NameError.

Une IndexError peut survenir 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 que 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 que c’est 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 suivantes :

• SettingWithCopyWarning dans Pandas : Comment corriger cet avertissement
• Cours : Manipulation des données avec pandas
• Cours : Écriture de code efficace avec pandas
• Fiche de triche : Traitement des données avec pandas
• Feuille de triche : Remodelage des données avec pandas