Fonction Python enumerate(), expliquée avec des exemples

Ce guide vous expliquera comment exploiter la fonction enumerate() en Python.

En Python, la fonction enumerate() offre une méthode concise pour obtenir à la fois les éléments d'un itérable et leurs indices associés.

Nous allons débuter par l'exploration des méthodes d'accès aux éléments et indices via une boucle simple, puis nous plongerons dans la syntaxe spécifique de la fonction enumerate(). Des exemples pratiques seront utilisés pour illustrer son fonctionnement.

Commençons sans plus tarder.

Itération à l'aide d'une boucle for en Python

Tout objet Python permettant de parcourir et d'accéder à ses éléments un par un est désigné comme un itérable. Par conséquent, les listes, les tuples, les dictionnaires et les chaînes de caractères Python sont tous des itérables.

Prenons l'exemple d'une liste de courses définie dans le bloc de code ci-dessous.

shopping_list = ["fruits","cookies","cereals","protein bars","post-it notes"]

En Python, la boucle for est l'outil privilégié pour itérer sur n'importe quel itérable. Voici la structure générale :

for item in <iterable>:
    # traitement de l'item

# item: variable de boucle
# <iterable>: tout itérable Python : liste, tuple, dictionnaire, chaîne de caractères, etc.

Appliquons cette structure pour parcourir notre shopping_list et accéder à chacun de ses éléments.

for item in shopping_list:
  print(item)

# Résultat
fruits
cookies
cereals
protein bars
post-it notes

Cette méthode permet d'accéder directement aux éléments. Toutefois, il peut être nécessaire d'accéder également à l'indice de chaque élément.

Une approche consiste à utiliser une variable d'indice et à l'incrémenter au sein de la boucle, comme suit :

index = 0
for item in shopping_list:
  print(f"index:{index}, {item}")
  index += 1

# Résultat
index:0, fruits
index:1, cookies
index:2, cereals
index:3, protein bars
index:4, post-it notes

Cependant, cette méthode n'est pas la plus efficace. Un oubli d'incrémentation de l'indice pourrait compromettre le bon déroulement du code.

index = 0
for item in shopping_list:
  print(f"index:{index}, {item}")
  # l'indice n'est pas mis à jour dans la boucle
  # l'indice reste toujours à 0

# Résultat
index:0, fruits
index:0, cookies
index:0, cereals
index:0, protein bars
index:0, post-it notes

Une autre méthode courante consiste à utiliser la boucle for en combinaison avec la fonction range(). Nous examinerons cette approche plus en détail dans la section suivante.

Utilisation de la fonction range() pour accéder aux indices

La fonction intégrée len() en Python retourne la longueur de tout objet. Ainsi, len(shopping_list) nous donne la longueur de shopping_list, qui est 5 dans ce cas.

len(shopping_list)
# Résultat: 5

La fonction range() retourne un objet de type range qui peut être itéré. En parcourant range(stop), on obtient les indices 0, 1, 2, ..., stop-1.

En définissant stop = len(list), vous pouvez obtenir la liste des indices valides. Ainsi, en utilisant la fonction range(), on peut accéder à la fois à l'indice et à l'élément correspondant, comme ci-dessous.

for index in range(len(shopping_list)):
  print(f"index:{index}, item: {shopping_list[index]}")

# Résultat
index:0, item: fruits
index:1, item: cookies
index:2, item: cereals
index:3, item: protein bars
index:4, item: post-it notes

Cependant, cette méthode n'est pas la plus "pythonique" pour accéder simultanément aux indices et aux éléments.

Syntaxe de la fonction enumerate() en Python

La fonction enumerate() de Python permet d'accéder aux éléments ainsi qu'à leurs indices, selon la syntaxe générale suivante :

enumerate(<iterable>, start = 0)

Dans cette syntaxe :

• <iterable> est un paramètre obligatoire. Il peut s'agir de n'importe quel itérable Python, comme une liste ou un tuple.
• start est un paramètre optionnel qui indique la valeur de départ de l'index. Si non spécifié, sa valeur par défaut est zéro.

En appelant enumerate(shopping_list), on obtient un objet d'énumération, comme illustré ci-dessous.

enumerate(shopping_list)
<enumerate at 0x7f91b4240410>

L'objet d'énumération n'est pas directement itérable. Nous allons donc le convertir en liste.

list(enumerate(shopping_list))

# Résultat
[(0, 'fruits'),
 (1, 'cookies'),
 (2, 'cereals'),
 (3, 'protein bars'),
 (4, 'post-it notes')]

Une autre méthode pour accéder aux éléments de l'objet d'énumération est d'utiliser la fonction next() en lui fournissant l'objet d'énumération comme argument. La fonction next() retourne l'élément suivant d'un itérateur.

En interne, la fonction next() appelle la méthode __next__ de l'itérateur pour récupérer les éléments successifs.

Affectons l'objet d'énumération à la variable shopping_list_enum.

shopping_list_enum = enumerate(shopping_list)

Le premier appel à next(shopping_list_enum) retourne l'indice zéro et l'élément à l'indice 0 : le tuple (0, 'fruits').

Les appels successifs à next() retournent les éléments suivants avec leurs indices, comme ci-dessous.

next(shopping_list_enum)
# (0, 'fruits')
next(shopping_list_enum)
# (1, 'cookies')
next(shopping_list_enum)
# (2, 'cereals')
next(shopping_list_enum)
# (3, 'protein bars')
next(shopping_list_enum)
# (4, 'post-it notes')

Que se passe-t-il si on appelle next() après avoir accédé à tous les éléments ? Une erreur StopIteration est levée.

next(shopping_list_enum)
# ---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-16-4220f68f6c7e> in <module>()
----> 1 next(shopping_list_enum)

StopIteration:

La fonction enumerate() retourne les indices et éléments au fur et à mesure qu'ils sont nécessaires, sans les calculer au préalable. Pour les projets Python où l'optimisation de la mémoire est essentielle, l'utilisation de enumerate() peut être judicieuse lors de l'itération sur de grands itérables.

Exemples d'utilisation de enumerate()

Maintenant que nous connaissons la syntaxe de la fonction enumerate(), modifions la boucle for que nous avions précédemment.

Comme nous l'avons vu, l'itération sur l'objet d'énumération retourne un tuple contenant l'indice et l'élément. On peut décomposer ce tuple en deux variables : index et item.

for index, item in enumerate(shopping_list):
  print(f"index:{index}, item:{item}")

# Résultat
index:0, item:fruits
index:1, item:cookies
index:2, item:cereals
index:3, item:protein bars
index:4, item:post-it notes

Voyons maintenant comment spécifier une valeur de départ personnalisée.

Utilisation de enumerate() avec une valeur de départ personnalisée

En Python, l'indexation commence à zéro. La valeur de départ par défaut est donc 0. Cependant, si vous avez besoin d'indices plus lisibles, en commençant à 1 ou un autre index de votre choix, vous pouvez spécifier une valeur de départ personnalisée.

Dans l'exemple de shopping_list, si vous souhaitez commencer le comptage à partir de 1, définissez start = 1.

for index, item in enumerate(shopping_list,1):
  print(f"index:{index}, item:{item}")

# Résultat
index:1, item:fruits
index:2, item:cookies
index:3, item:cereals
index:4, item:protein bars
index:5, item:post-it notes

Il est important de noter que la valeur de départ personnalisée doit être spécifiée comme deuxième argument positionnel.

En inversant l'ordre de l'itérable et de la valeur de départ, une erreur sera levée, comme expliqué ci-dessous.

for index, item in enumerate(1,shopping_list):
  print(f"index:{index}, item:{item}")

# Résultat
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-12-5dbf7e2749aa> in <module>()
----> 1 for index, item in enumerate(1,shopping_list):
      2   print(f"index:{index}, item:{item}")

TypeError: 'list' object cannot be interpreted as an integer

Pour éviter ce type d'erreur, vous pouvez spécifier start comme argument nommé, comme ci-dessous.

for index, item in enumerate(shopping_list, start = 1):
  print(f"index:{index}, item:{item}")

# Résultat
index:1, item:fruits
index:2, item:cookies
index:3, item:cereals
index:4, item:protein bars
index:5, item:post-it notes

Nous avons vu comment utiliser enumerate() avec des listes. On peut également utiliser enumerate() pour parcourir des chaînes de caractères, des dictionnaires et des tuples.

Utilisation de enumerate() avec des tuples Python

Imaginons que shopping_list soit un tuple. Les tuples, tout comme les listes, sont des collections, mais sont immuables. Il est donc impossible de les modifier, toute tentative en ce sens lèvera une erreur.

L'extrait de code suivant initialise shopping_list en tant que tuple.

shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
type(shopping_list)
# Tuple

Toute tentative de modification du premier élément du tuple se soldera par une erreur, car un tuple est une collection immuable.

shopping_list[0] = 'vegetables'

# Résultat
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-ffdafa961600> in <module>()
----> 1 shopping_list[0] = 'vegetables'

TypeError: 'tuple' object does not support item assignment

▶ Exécutons le code suivant pour vérifier que enumerate() fonctionne correctement avec les tuples.

shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
for index, item in enumerate(shopping_list):
    print(f"index:{index}, item:{item}")

Utilisation de enumerate() avec des chaînes de caractères Python

La fonction enumerate() peut également être utilisée pour parcourir les chaînes de caractères et accéder simultanément à leurs caractères et indices.

Voici un exemple.

py_str="Butterfly"
for index, char in enumerate(py_str):
  print(f"index {index}: {char}")

# Résultat
index 0: B
index 1: u
index 2: t
index 3: t
index 4: e
index 5: r
index 6: f
index 7: l
index 8: y

Comme on le voit, les caractères et leurs indices (de 0 à 8) ont été affichés.

Conclusion 👩🏽‍💻

Récapitulons ce que nous avons appris :

• Vous pouvez utiliser des boucles for pour accéder aux éléments tout en maintenant un compteur ou une variable d'indice.
• La fonction range() permet d'obtenir les indices valides pour accéder aux éléments par indexation.
• La méthode Pythonique recommandée est d'utiliser enumerate() avec la syntaxe : enumerate(iterable). Par défaut, le décompte commence à 0.
• Vous pouvez personnaliser la valeur de départ avec la syntaxe enumerate(iterable, start).
• enumerate() peut être utilisé avec des tuples, des chaînes de caractères, des dictionnaires et tout itérable Python.

J'espère que ce tutoriel sur enumerate() vous a été utile. Vous pouvez maintenant apprendre à trouver l'indice d'un élément dans les listes Python. Continuez à coder !