Selecting Data with .loc and .iloc

1. La différence fondamentale : Étiquette vs. Position

La distinction la plus importante à comprendre est la suivante :

• .loc sélectionne les données en se basant sur leurs étiquettes (labels).
• .iloc sélectionne les données en se basant sur leur position (un index entier, commençant à 0).

Imaginez une bibliothèque. Utiliser .loc serait comme demander un livre par son titre (par exemple, "L'Étranger"). Utiliser .iloc serait comme demander "le 5ème livre sur la 3ème étagère". Les deux méthodes peuvent vous donner le même livre, mais la manière de le demander est fondamentalement différente.

L'image suivante illustre parfaitement cette distinction avec un exemple simple.

Pour bien explorer cette différence, créons notre propre DataFrame. Nous allons utiliser un tableau de notes d'étudiants, où les noms des étudiants serviront d'étiquettes pour les lignes.

import pandas as pd




# Création d'un dictionnaire de données
data = {'Maths': [15, 12, 18, 9],
        'Physique': [13, 16, 17, 11],
        'Chimie': [11, 14, 15, 12]}




# Création des étiquettes de ligne (index)
index_labels = ['Ahmed', 'Fatima', 'Youssef', 'Aisha']




# Création du DataFrame
df_notes = pd.DataFrame(data, index=index_labels)




# Affichage du DataFrame
print(df_notes)

Résultat :

         Maths  Physique  Chimie
Ahmed       15        13      11
Fatima      12        16      14
Youssef     18        17      15
Aisha        9        11      12

Ce DataFrame sera notre terrain de jeu pour comprendre .loc et .iloc.

2. Sélection par étiquette avec .loc

Avec .loc, nous utilisons les noms que nous avons donnés à nos lignes et colonnes. La syntaxe générale est df.loc[etiquettes_lignes, etiquettes_colonnes].

L'article suivant de DataCamp est une excellente référence qui détaille l'utilisation de .loc. Nous allons en parcourir les concepts clés avec notre exemple.

Appliquons ces concepts à notre df_notes:

• Sélectionner une seule ligne (les notes de Fatima) :

  print(df_notes.loc['Fatima'])
  

  Résultat : une Series Pandas contenant les notes de Fatima.

• Sélectionner plusieurs lignes (Ahmed et Aisha) :
  On passe une liste d'étiquettes.

  print(df_notes.loc[['Ahmed', 'Aisha']])
  

• Sélectionner une tranche de lignes (de Fatima à Youssef) :
  La grande particularité de .loc est que la borne de fin est incluse.

  print(df_notes.loc['Fatima':'Youssef']) 
  

  Ceci retournera les lignes pour Fatima ET Youssef.

• Sélectionner une seule colonne (toutes les notes de Physique) :
  Le : signifie "toutes les lignes".

  print(df_notes.loc[:, 'Physique'])
  

• Combiner la sélection de lignes et de colonnes :
  Obtenons la note de Maths de Youssef.

  print(df_notes.loc['Youssef', 'Maths'])
  

  Résultat : 18

3. Sélection par position avec .iloc

Maintenant, passons à .iloc. Oublions les noms des étudiants et des matières. Nous ne nous intéressons qu'à leur position dans le tableau, en commençant par 0. La syntaxe est df.iloc[positions_lignes, positions_colonnes].

Continuons notre lecture de l'article de DataCamp pour explorer .iloc.

Appliquons iloc à notre df_notes:

• Sélectionner une seule ligne (la deuxième ligne, qui correspond à Fatima) :
  La position de Fatima est 1 (car on commence à 0).

  print(df_notes.iloc[1])
  

• Sélectionner plusieurs lignes (la première et la quatrième, Ahmed et Aisha) :
  On utilise leurs positions 0 et 3.

  print(df_notes.iloc[[0, 3]])
  

• Sélectionner une tranche de lignes (de la deuxième à la troisième, Fatima et Youssef) :
  Avec .iloc, la borne de fin est exclue. Pour obtenir les lignes aux positions 1 et 2, nous devons aller jusqu'à 3.

  print(df_notes.iloc[1:3])
  

  Ceci retournera les lignes pour Fatima et Youssef, mais pas la ligne à la position 3 (Aisha). C'est une différence fondamentale avec .loc.

• Sélectionner une seule colonne (la deuxième colonne, Physique) :
  La colonne 'Physique' est à la position 1.

  print(df_notes.iloc[:, 1])
  

• Combiner la sélection de lignes et de colonnes :
  Obtenons la note dans la première colonne ('Maths', position 0) pour le troisième étudiant ('Youssef', position 2).

  print(df_notes.iloc[2, 0])
  

  Résultat : 18

Pour une démonstration visuelle de ces concepts, la vidéo suivante est une excellente ressource. L'instructeur, Corey Schafer, part de zéro et explique très clairement la logique.

4. Quand utiliser .loc vs .iloc ?

Voici une règle simple pour vous guider :

Une erreur fréquente avec .loc est la KeyError, qui survient si vous essayez d'accéder à une étiquette qui n'existe pas. Avec .iloc, l'erreur correspondante est IndexError, qui survient si vous demandez une position en dehors des limites du DataFrame. Soyez toujours attentif aux dimensions de votre DataFrame (avec df.shape) pour éviter ces erreurs.

Exercice pratique

Utilisons le DataFrame df_notes que nous avons créé pour mettre en pratique ce que vous avez appris.

Vos tâches :

1. Sélectionnez toutes les notes de 'Youssef' en utilisant .loc.
2. Sélectionnez les notes du deuxième étudiant dans le tableau en utilisant .iloc.
3. Sélectionnez uniquement les notes de 'Maths' et 'Chimie' pour tous les étudiants, en utilisant .loc.
4. Sélectionnez la première et la troisième colonne pour tous les étudiants, en utilisant .iloc.
5. En une seule commande, sélectionnez les notes de 'Physique' pour 'Fatima' et 'Youssef'.

Solutions

# 1. Sélectionner les notes de 'Youssef' avec .loc
print("1. Notes de Youssef:")
print(df_notes.loc['Youssef'])
print("\n" + "="*30 + "\n")




# 2. Sélectionner le deuxième étudiant avec .iloc (position 1)
print("2. Notes du deuxième étudiant (Fatima):")
print(df_notes.iloc[1])
print("\n" + "="*30 + "\n")




# 3. Sélectionner les colonnes 'Maths' et 'Chimie' avec .loc
print("3. Notes de Maths et Chimie:")
print(df_notes.loc[:, ['Maths', 'Chimie']])
print("\n" + "="*30 + "\n")




# 4. Sélectionner la première et troisième colonne avec .iloc (positions 0 et 2)
print("4. Première et troisième colonnes:")
print(df_notes.iloc[:, [0, 2]])
print("\n" + "="*30 + "\n")




# 5. Sélectionner les notes de Physique pour Fatima et Youssef
print("5. Notes de Physique pour Fatima et Youssef:")
print(df_notes.loc[['Fatima', 'Youssef'], 'Physique'])

Résultat attendu :

1. Notes de Youssef:
Maths       18
Physique    17
Chimie      15
Name: Youssef, dtype: int64

==============================

2. Notes du deuxième étudiant (Fatima):
Maths       12
Physique    16
Chimie      14
Name: Fatima, dtype: int64

==============================

3. Notes de Maths et Chimie:
         Maths  Chimie
Ahmed       15      11
Fatima      12      14
Youssef     18      15
Aisha        9      12

==============================

4. Première et troisième colonnes:
         Maths  Chimie
Ahmed       15      11
Fatima      12      14
Youssef     18      15
Aisha        9      12

==============================

5. Notes de Physique pour Fatima et Youssef:
Fatima     16
Youssef    17
Name: Physique, dtype: int64

Conclusion

Félicitations ! Vous avez franchi une étape essentielle dans votre apprentissage de Pandas. Savoir naviguer avec précision dans un DataFrame est une compétence que vous utiliserez constamment.

Les points clés à retenir :

• .loc sélectionne par étiquette. Le découpage en tranches (slice) est inclusif.
• .iloc sélectionne par position entière. Le découpage en tranches est exclusif.
• La syntaxe générale est df.accessor[lignes, colonnes], où accessor est soit .loc soit .iloc.

Maintenant que nous pouvons sélectionner des données par leur position ou leur étiquette, que se passe-t-il si nous voulons sélectionner des données en fonction de leurs valeurs ? Par exemple, comment sélectionner "tous les étudiants qui ont eu plus de 15 en Maths" ? C'est ce qu'on appelle le filtrage booléen, et c'est l'une des fonctionnalités les plus puissantes de Pandas que nous aborderons dans la prochaine leçon.