Dans ce tutoriel, vous découvrirez comment localiser l’indice d’un élément au sein d’une liste Python, en utilisant des méthodes d’itération simples ainsi que la fonction intégrée `index()`.
Lorsque vous travaillez avec des listes en Python, il est souvent nécessaire de connaître la position spécifique d’un élément. Pour ce faire, vous avez deux options principales :
- Parcourir la liste en vérifiant à chaque itération si l’élément à l’indice actuel correspond à la valeur que vous recherchez.
- Utiliser la méthode `index()` intégrée directement sur la liste.
Ce guide vous expliquera ces deux approches en détail. Commençons l’exploration. 👩🏽💻
Rappel sur les listes Python
En Python, une liste est une collection ordonnée d’éléments, qui peuvent être de types de données identiques ou variés. Les listes sont mutables, ce qui signifie que vous pouvez les modifier directement sans avoir à créer une nouvelle liste.
Considérons cet exemple concret : une liste de 5 fruits différents.
fruits = ["pomme","mangue","fraise","grenade","melon"]
La fonction intégrée `len()` vous permet de déterminer la longueur de tout objet Python. En l’appliquant à une liste, comme `len(fruits)`, vous obtenez le nombre d’éléments qu’elle contient.
len(fruits) # Résultat: 5
Nous utiliserons cette liste de fruits comme exemple principal tout au long de ce tutoriel.
Indexation dans les listes Python
Python utilise une indexation basée sur zéro. Cela signifie que dans toute séquence (itérable), le premier élément se trouve à l’index 0, le second à l’index 1, et ainsi de suite. Si la longueur de la séquence est `k`, alors le dernier élément se trouve à l’index `k – 1`.
En Python, la fonction `range()` est utile pour générer des indices lorsque vous parcourez des séquences.
Remarque : Lorsque vous itérez avec `range(k)`, vous obtenez les indices 0, 1, 2,…, `k-1`. En fixant `k` à la longueur de la liste (`len(list)`), vous générez tous les indices valides.
L’exemple de code suivant illustre cette notion.
for i in range(len(fruits)):
print(f"i:{i}, fruit[{i}] est {fruits[i]}")
# Résultat
i:0, fruit[0] est pomme
i:1, fruit[1] est mangue
i:2, fruit[2] est fraise
i:3, fruit[3] est grenade
i:4, fruit[4] est melon
Maintenant que nous avons revu les bases des listes Python, passons à la recherche d’un indice spécifique dans une liste.
Localisation de l’indice d’un élément par itération avec des boucles `for`
Reprenons notre liste de fruits. Nous allons explorer comment trouver l’index d’un élément précis en itérant sur la liste avec une boucle `for`.
Utilisation combinée de la boucle `for` et de `range()`
Commençons par définir une cible : la valeur que nous voulons trouver dans la liste.
Nous pouvons utiliser la boucle `for` en combinaison avec `range()` pour obtenir une séquence d’indices allant de 0 à `len(fruits) – 1`.
- Nous parcourons la liste des fruits en accédant à chaque indice.
- À chaque indice `i`, nous vérifions si l’élément correspondant est égal à la cible.
- Si la condition est vraie, nous affichons que la cible a été trouvée à l’indice `i`.
fruits = ["pomme","mangue","fraise","grenade","melon"]
target = "mangue"
for i in range(len(fruits)):
if fruits[i] == target:
print(f"{target} trouvé à l'indice {i}")
# Résultat
mangue trouvé à l'indice 1
Dans cet exemple, la chaîne cible « mangue » apparaît une seule fois (à l’index 1) dans la liste `fruits`.
Il est possible que la valeur cible apparaisse plusieurs fois, voire pas du tout. Pour gérer ces cas, nous allons modifier la boucle et la placer dans une fonction nommée `find_in_list`.
Explication de la définition de la fonction
La fonction `find_in_list` prend deux arguments :
- `cible` : la valeur que vous recherchez, et
- `py_list` : la liste Python dans laquelle vous effectuez la recherche.
def find_in_list(target,py_list):
target_indices = []
for i in range(len(fruits)):
if fruits[i] == target:
target_indices.append(i)
if target_indices == []:
print("Désolé, cible non trouvée !")
else:
print(f"{target} se trouve aux indices {target_indices}")
Au sein de la fonction, nous initialisons une liste vide `target_indices`. Nous parcourons ensuite la liste. Chaque fois que la cible est trouvée à un indice donné, nous ajoutons cet indice à la liste `target_indices` en utilisant la méthode `append()`.
Remarque : En Python, `list.append(item)` ajoute un élément à la fin de la liste.
- Si la cible n’est jamais trouvée, `target_indices` reste vide, et un message indique que la cible est absente de la liste.
- Si la cible apparaît à plusieurs indices, `target_indices` contiendra tous ces indices.
Modifions maintenant la liste de fruits comme suit.
Cette fois, nous recherchons la chaîne « mangue », qui apparaît deux fois, aux indices 1 et 4.
fruits = ["pomme","mangue","fraise","grenade","mangue","melon"] target = "mangue" find_in_list(target,fruits) # Résultat mangue se trouve aux indices [1, 4]
En appelant la fonction `find_in_list` avec `target` et `fruits` en arguments, nous obtenons bien les deux indices.
target = "navet" find_in_list(target,fruits) # Résultat Désolé, cible non trouvée !
Si vous essayez de rechercher « navet » qui n’est pas dans la liste de fruits, un message vous avertit que la cible n’a pas été trouvée.
Utilisation de la boucle `for` et de `enumerate()`
La fonction `enumerate()` de Python permet d’accéder simultanément à l’index et à l’élément lors de l’itération, sans avoir besoin de la fonction `range()`.
Le code suivant illustre l’utilisation de `enumerate()` pour obtenir à la fois les indices et les éléments.
fruits = ["pomme","mangue","fraise","grenade","mangue","melon"]
for index,fruit in enumerate(fruits):
print(f"Index {index}: {fruit}")
# Résultat
Index 0: pomme
Index 1: mangue
Index 2: fraise
Index 3: grenade
Index 4: mangue
Index 5: melon
Réécrivons la fonction Python de recherche d’indices à l’aide de `enumerate()`.
def find_in_list(target,py_list):
target_indices = []
for index, fruit in enumerate(fruits):
if fruit == target:
target_indices.append(index)
if target_indices == []:
print("Désolé, cible non trouvée !")
else:
print(f"{target} se trouve aux indices {target_indices}")
Comme dans la section précédente, vous pouvez maintenant appeler la fonction `find_in_list` avec des arguments appropriés.
La définition de fonction ci-dessus peut être traduite en une compréhension de liste équivalente, que nous allons explorer dans la section suivante.
Localisation de l’indice d’un élément par itération avec une compréhension de liste
Les compréhensions de liste en Python offrent un moyen concis de créer des listes à partir d’autres listes, en appliquant certaines conditions. La structure générale est la suivante :
nouvelle_liste = [<expression> for <éléments dans les itérables existants> if <condition est vraie>]
Le schéma ci-dessous illustre comment identifier les éléments d’une compréhension de liste ; en l’utilisant, vous pouvez convertir la fonction `find_in_list` en compréhension de liste.
En suivant ce schéma, l’expression de compréhension de liste pour générer les indices cibles devient :
target_indices = [index for index,fruit in enumerate(fruits) if fruit==target]
À titre d’exercice, essayez d’exécuter ce code pour d’autres exemples.
Localisation d’un indice avec la méthode `index()`
Pour trouver l’index d’un élément, vous pouvez aussi utiliser la méthode intégrée `.index()`. Voici la syntaxe générale :
liste.index(valeur, début, fin)
Décortiquons cette méthode :
- `valeur` est la valeur cible que vous recherchez.
- `début` et `fin` sont des arguments optionnels ; ils permettent de rechercher l’indice d’un élément dans une portion spécifique de la liste, allant de `début` jusqu’à `fin – 1`.
Remarque : La méthode `.index()` ne retourne que l’indice de la première occurrence de `valeur`. Même en effectuant une recherche dans une portion de liste `[début: fin-1]`, la méthode retourne l’indice de la première occurrence de l’élément dans cette portion.
Reprenons notre exemple pour illustrer le fonctionnement de `.index()`.
fruits = ["pomme","mangue","fraise","grenade","mangue","melon"] target = "mangue" fruits.index(target) 1
Bien que « mangue » apparaisse deux fois dans la liste, seul l’indice de la première occurrence est renvoyé.
Pour obtenir l’indice de la seconde occurrence, nous pouvons effectuer une recherche dans la portion de la liste commençant à l’index 2 et allant jusqu’à l’index 5, comme ci-dessous.
fruits.index(target,2,5) 4
Gestion des erreurs `ValueError`
Voyons ce qui se passe si vous essayez de trouver l’indice d’un élément absent de la liste, par exemple « carotte ».
target = "carotte"
fruits.index(target)
# Résultat
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-17-81bd454e44f7> in <module>()
1 target = "carotte"
2
----> 3 fruits.index(target)
ValueError: 'carotte' n'est pas dans la liste
Comme le montre l’exemple, cela déclenche une erreur `ValueError`. En Python, vous pouvez gérer cette erreur en utilisant les blocs `try` et `except`.
La syntaxe générale pour utiliser `try-except` est la suivante :
try: # exécuter ce code except <TypeErreur>: # exécuter ce code si une <TypeErreur> survient
En utilisant ces blocs, nous pouvons gérer l’erreur `ValueError`.
target = "carotte"
try:
fruits.index(target)
except ValueError:
print(f"Désolé, impossible de trouver {target} dans la liste")
# Résultat
Désolé, impossible de trouver carotte dans la liste
Ce code réalise les actions suivantes :
- Si la cible est présente dans la liste, il retourne son index.
- Si la cible n’est pas présente, il gère l’erreur `ValueError` et affiche un message d’erreur.
Récapitulatif
Voici un récapitulatif des méthodes que vous avez apprises pour localiser l’indice d’un élément dans une liste Python.
- Vous pouvez utiliser la boucle `for` et la fonction `range()` pour accéder aux éléments et à leurs indices. Vérifiez si l’élément à un indice spécifique correspond à la cible.
- Vous pouvez utiliser la fonction `enumerate()` pour accéder simultanément aux éléments et à leurs indices.
- Ces deux méthodes peuvent être implémentées au sein d’une compréhension de liste.
- Pour localiser l’indice d’un élément, vous pouvez également utiliser la méthode intégrée `.index()`.
- `list.index(valeur)` retourne l’indice de la première occurrence de `valeur`. Si la valeur n’est pas présente, une erreur `ValueError` est déclenchée.
- Pour rechercher dans une portion de liste, utilisez `list.index(valeur, début, fin)` afin de cibler la portion `[début: fin-1]`.
Poursuivez votre apprentissage en explorant le tri d’un dictionnaire Python par clé ou par valeur. Bonne programmation Python !