Enumerate Python : Comment Parcourir Listes et Index Simultanément ?

Besoin de l’index en même temps que l’élément quand vous parcourez une liste en Python ? Oubliez les compteurs manuels.

Ce guide vous montre comment utiliser la fonction `enumerate` avec des exemples clairs et simples à copier.

Qu’est-ce que la fonction `enumerate` en Python ?

La fonction `enumerate` est un outil intégré à Python. Son rôle est simple : elle ajoute un compteur à un objet itérable. Un objet itérable, c’est n’importe quoi que vous pouvez parcourir dans une boucle, comme une liste, un tuple ou une chaîne de caractères.

Au lieu de retourner juste l’élément, `enumerate` vous donne un `enumerate object`. Cet objet spécial produit des paires sous forme de tuples : `(index, élément)`. C’est beaucoup plus direct que de gérer un compteur à la main.

enumerate(iterable, start=0)

Elle prend deux paramètres :

• `iterable` : C’est l’objet que vous voulez parcourir (une liste, par exemple). Ce paramètre est obligatoire.
• `start` : C’est un chiffre qui indique où le compteur doit commencer. Ce paramètre est optionnel, et sa valeur par défaut est 0.

Exemple simple d’itération sur une liste

Le cas le plus courant est de parcourir une liste. Imaginons une liste de couleurs. Vous voulez afficher chaque couleur avec sa position dans la liste.

couleurs = ['bleu', 'rouge', 'jaune']

for index, couleur in enumerate(couleurs):
    print(f"Index: {index}, Couleur: {couleur}")

Ce code va afficher le résultat suivant :

Index: 0, Couleur: bleu
Index: 1, Couleur: rouge
Index: 2, Couleur: jaune

Comme vous le voyez, la boucle `for` récupère directement l’index et l’élément à chaque tour, sans effort. C’est le principe de la fonction `enumerate` en Python.

Vous pouvez aussi transformer directement un `enumerate object` en liste de tuples. C’est utile pour voir d’un coup toutes les paires index/élément.

couleurs = ['bleu', 'rouge', 'jaune']
resultat_en_liste = list(enumerate(couleurs))

print(resultat_en_liste)

Le résultat sera une liste de tuples :

[(0, 'bleu'), (1, 'rouge'), (2, 'jaune')]

Changer l’index de départ avec le paramètre `start`

Par défaut, l’indexation commence à 0. Mais parfois, vous voulez que la numérotation commence à 1, ou même à 100. C’est là que le paramètre `start` devient utile.

Il suffit de le préciser lors de l’appel à la fonction `enumerate`. Par exemple, pour commencer à compter à partir de 1 :

couleurs = ['bleu', 'rouge', 'jaune', 'orange']

# On utilise start=1 pour commencer l'index à 1
for index, couleur in enumerate(couleurs, start=1):
    print(f"Position: {index}, Couleur: {couleur}")

Le résultat est maintenant numéroté de manière plus « humaine » :

Position: 1, Couleur: bleu
Position: 2, Couleur: rouge
Position: 3, Couleur: jaune
Position: 4, Couleur: orange

C’est une option très pratique pour afficher des listes numérotées, des classements ou toute situation où un index commençant à zéro n’a pas de sens pour l’utilisateur final.

Cas d’usages concrets et avancés de `enumerate`

La fonction `enumerate` ne se limite pas aux listes simples. Elle est flexible et peut être utilisée avec n’importe quel `iterable` et combinée avec d’autres fonctions Python.

Itérer sur différents types d’itérables

`enumerate` fonctionne sur bien plus que les listes. Voici quelques exemples.

Sur une chaîne de caractères (string)

Une chaîne de caractères est une séquence de lettres. `enumerate` peut donc la parcourir pour obtenir l’index de chaque lettre.

mot = "python"

for index, lettre in enumerate(mot):
    print(f"Index {index}: {lettre}")

Résultat :

Index 0: p
Index 1: y
Index 2: t
Index 3: h
Index 4: o
Index 5: n

Sur un dictionnaire

Pour un dictionnaire, il faut utiliser la méthode `.items()` qui retourne des paires (clé, valeur). `enumerate` va alors numéroter ces paires.

mon_dict = {'a': 'pomme', 'b': 'banane'}

for index, (cle, valeur) in enumerate(mon_dict.items()):
    print(f"Item {index}: la clé est '{cle}' et la valeur est '{valeur}'")

Résultat :

Item 0: la clé est 'a' et la valeur est 'pomme'
Item 1: la clé est 'b' et la valeur est 'banane'

Sur un tuple

Un tuple fonctionne exactement comme une liste avec `enumerate`.

mon_tuple = (10, 20, 30)

for index, valeur in enumerate(mon_tuple):
    print(f"Index {index} -> Valeur {valeur}")

Résultat :

Index 0 -> Valeur 10
Index 1 -> Valeur 20
Index 2 -> Valeur 30

Filtrer des éléments en fonction de leur index

Comme `enumerate` vous donne l’index, vous pouvez l’utiliser pour appliquer une logique. Par exemple, pour ne traiter que les éléments situés à un index pair.

nombres = [10, 11, 12, 13, 14, 15]

for index, nombre in enumerate(nombres):
    # On vérifie si l'index est pair
    if index % 2 == 0:
        print(f"L'élément à l'index pair {index} est {nombre}")

Résultat :

L'élément à l'index pair 0 est 10
L'élément à l'index pair 2 est 12
L'élément à l'index pair 4 est 14

Créer un dictionnaire à partir d’une séquence

Vous pouvez utiliser `enumerate` avec une compréhension de dictionnaire pour créer rapidement un dictionnaire où les clés sont les index et les valeurs sont les éléments de la liste.

fruits = ['pomme', 'banane', 'cerise']

# On crée un dictionnaire {index: fruit}
fruits_dict = {index: fruit for index, fruit in enumerate(fruits)}

print(fruits_dict)

Le dictionnaire créé sera :

{0: 'pomme', 1: 'banane', 2: 'cerise'}

Parcourir plusieurs listes en même temps avec `zip()`

Si vous avez plusieurs listes liées (par exemple, des produits et leurs prix), vous pouvez les combiner avec la fonction `zip()`. Ensuite, `enumerate` peut numéroter ces paires.

`zip()` regroupe les éléments des listes deux par deux (ou plus). `enumerate` ajoute un index global à chaque groupe.

produits = ['Café', 'Thé', 'Jus']
prix = [3.50, 2.80, 4.10]

# zip(produits, prix) crée des paires ('Café', 3.50), ('Thé', 2.80), etc.
for index, (produit, prix_unitaire) in enumerate(zip(produits, prix), start=1):
    print(f"{index}. Produit: {produit}, Prix: {prix_unitaire}€")

Le résultat est une liste numérotée et bien formatée :

1. Produit: Café, Prix: 3.50€
2. Produit: Thé, Prix: 2.80€
3. Produit: Jus, Prix: 4.10€

Utiliser `next()` pour un contrôle manuel

L’objet retourné par `enumerate` est un itérateur. Cela signifie que vous pouvez le « consommer » élément par élément avec la fonction `next()`, sans avoir besoin d’une boucle `for`.

C’est utile pour des cas plus avancés où vous avez besoin de contrôler précisément l’itération.

lettres = ['a', 'b', 'c']
enumerate_object = enumerate(lettres)

# On récupère le premier élément
print(next(enumerate_object))

# On récupère le deuxième
print(next(enumerate_object))

Résultat :

(0, 'a')
(1, 'b')

Chaque appel à `next()` avance d’un pas dans la séquence et retourne le tuple `(index, element)` suivant.

Pourquoi utiliser `enumerate` ? Les avantages en résumé

Utiliser `enumerate` n’est pas juste une question de préférence. C’est une pratique qui améliore la qualité de votre code Python. Voici les raisons principales.

• Code plus simple et lisible : Vous évitez de gérer un compteur manuellement. Le code est plus court et plus direct.

  Avant (moins bien) :

  compteur = 0
  for couleur in couleurs:
      print(compteur, couleur)
      compteur += 1

  Après (mieux) :

  for index, couleur in enumerate(couleurs):
      print(index, couleur)

• Plus « Pythonique » : C’est la manière standard et recommandée par la communauté Python pour gérer les index dans une boucle. Utiliser `enumerate` montre que vous connaissez les bonnes pratiques du langage.
• Meilleures performances : Dans certains cas, `enumerate` est plus efficace. L’alternative qui consiste à chercher l’index d’un élément avec `list.index()` dans une boucle est beaucoup plus lente, car elle reparcourt la liste à chaque fois.

La fonction `enumerate` n’est pas un simple gadget. C’est un outil fondamental pour écrire du code Python propre, efficace et facile à lire. Elle simplifie une tâche très courante : parcourir une séquence quand on a besoin à la fois de l’élément et de sa position.

Intégrez-la dans vos habitudes pour rendre votre code plus professionnel.