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

Ce tutoriel vous apprendra à utiliser la fonction enumerate() en Python.

La fonction enumerate() en Python fournit une syntaxe concise pour accéder aux éléments d’un itérable avec leurs index.

Nous commencerons par examiner comment accéder aux éléments et aux index à l’aide d’une boucle simple, puis nous apprendrons la syntaxe de la fonction enumerate() de Python. Nous allons également coder des exemples en cours de route.

Commençons.

Comment itérer à l’aide de la boucle for en Python

Tout objet Python sur lequel vous pouvez parcourir et accéder aux éléments individuels, un à la fois, est appelé un itérable. Par conséquent, les listes Python, les tuples, les dictionnaires et les chaînes sont tous itérables.

Prenons un exemple de liste de courses définie dans la cellule de code ci-dessous.

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

En Python, vous pouvez utiliser la boucle for pour parcourir n’importe quel itérable. La syntaxe pour ce faire est la suivante :

for item in <iterable>:
    # do something on item

# item: looping variable
# <iterable>: any Python iterable: list, tuple, dictionary, string, and so on.

Maintenant, en utilisant cette syntaxe, parcourons shopping_list et accédons aux éléments individuels.

for item in shopping_list:
  print(item)

# Output
fruits
cookies
cereals
protein bars
post-it notes

Cette construction vous aide à accéder directement aux éléments. Cependant, vous devrez parfois accéder à l’index des éléments, en plus des éléments eux-mêmes.

Vous pouvez utiliser une variable d’index, que vous pouvez incrémenter dans le corps de la boucle, comme indiqué ci-dessous :

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

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

Mais ce n’est pas la méthode la plus efficace. Si vous ne vous souvenez pas d’incrémenter l’index, votre code ne fonctionnera pas comme prévu.

index = 0
for item in shopping_list:
  print(f"index:{index}, {item}")
  # no update of index inside loop body
  # index is never updated and is always 0

# Output
index:0, fruits
index:0, cookies
index:0, cereals
index:0, protein bars
index:0, post-it notes

Un autre modèle courant d’utilisation de la boucle for est en conjonction avec la fonction range(). Nous en apprendrons davantage dans la section suivante.

Comment utiliser la fonction range() pour accéder à l’index

La fonction intégrée len() de Python renvoie la longueur de tout objet Python. Vous pouvez donc appeler la fonction len() avec shopping_list comme argument pour obtenir la longueur de shopping_list (qui est 5, dans ce cas).

len(shopping_list)
# Output: 5

La fonction range() renvoie un objet range que vous pouvez ensuite utiliser en boucle. Lorsque vous parcourez la plage (arrêt), vous obtenez 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(), vous pouvez accéder à l’index ainsi qu’à l’élément correspondant, comme indiqué ci-dessous.

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

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

Cependant, ce n’est pas la méthode Pythonic recommandée pour accéder simultanément aux index et aux éléments.

Syntaxe de la fonction Python enumerate()

La fonction enumerate() de Python vous permet d’accéder aux éléments avec leurs indices en utilisant la syntaxe générale suivante :

enumerate(<iterable>, start = 0)

Dans la syntaxe ci-dessus :

  • est un paramètre obligatoire, et il peut s’agir de n’importe quel itérable Python, tel qu’une liste ou un tuple.
  • start est un paramètre facultatif qui contrôle l’index auquel le comptage commence. Si vous ne spécifiez pas la valeur de start, sa valeur par défaut est zéro.

Vous pouvez maintenant appeler la fonction enumerate() avec shopping_list et elle renvoie un objet énumération, comme indiqué dans la cellule de code ci-dessous.

enumerate(shopping_list)
<enumerate at 0x7f91b4240410>

Vous ne pouvez pas parcourir l’objet d’énumération. Convertissons donc l’objet énuméré en une liste Python.

list(enumerate(shopping_list))

# Output
[(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 consiste à appeler le fonction suivante() avec l’objet énuméré comme argument. En Python, la fonction next() renvoie l’élément suivant d’un itérateur.

En interne, la fonction next() fonctionne en appelant la méthode __next__ sur l’objet itérateur pour récupérer les éléments successifs.

Attribuons l’objet d’énumération à la variable shopping_list_enum.

shopping_list_enum = enumerate(shopping_list)

Lorsque vous appelez next() pour la première fois avec shopping_list_enum, vous obtenez l’index zéro et l’élément à l’index 0 : le tuple (0, ‘fruits’).

Lorsque vous continuez à faire d’autres appels à la fonction next(), vous obtiendrez les éléments successifs avec leurs indices, comme décrit 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 vous appelez la fonction next() après avoir accédé à tous les éléments et atteint la fin de la liste ? Vous obtenez une erreur StopIteration.

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() renvoie les indices et éléments successifs uniquement lorsque cela est nécessaire et ne sont pas calculés à l’avance. Dans les projets Python où vous devez prendre en compte l’efficacité de la mémoire, vous pouvez essayer d’utiliser la fonction enumerate() lorsque vous devez parcourir de grands itérables.

Exemples de fonctions Python enumerate()

Maintenant que nous avons appris la syntaxe pour utiliser la fonction enumerate(), modifions la boucle for que nous avions précédemment.

D’après la section précédente, nous savons que la boucle sur l’objet énumération renvoie un tuple avec l’index et l’élément. Nous pouvons décompresser ce tuple en deux variables : index et item.

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

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

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

Comment énumérer () avec une valeur de départ personnalisée

Python suit l’indexation zéro, donc la valeur de départ est 0 par défaut. Toutefois, si vous avez besoin des index sous une forme lisible par l’homme, à partir de 1 ou de tout autre index de votre choix, vous pouvez spécifier une valeur de départ personnalisée.

Dans l’exemple shopping_list, si vous souhaitez commencer à compter à partir de 1, définissez start = 1.

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

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

Cependant, lorsque vous spécifiez la valeur de départ personnalisée, vous devez vous assurer de la spécifier comme deuxième argument positionnel.

Si vous échangez par erreur l’ordre de l’itérable et la valeur de départ, vous rencontrerez une erreur, comme expliqué dans la cellule de code ci-dessous.

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

# Output
---------------------------------------------------------------------------
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 de telles erreurs, vous pouvez spécifier start comme argument de mot-clé, comme indiqué ci-dessous.

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

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

Jusqu’à présent, vous avez appris à utiliser la fonction enumerate() avec des listes Python. Vous pouvez également utiliser la fonction enumerate pour parcourir les chaînes Python, les dictionnaires et les tuples.

Comment utiliser la fonction enumerate() avec Python Tuples

Supposons que shopping_list est un tuple. En Python, les tuples sont également des collections, similaires aux listes Python, mais elles sont immuables. Par conséquent, vous ne pouvez pas les modifier et essayer de le faire entraînera 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

Si vous essayez de modifier le premier élément du tuple, vous obtiendrez une erreur car un tuple Python est une collection immuable.

shopping_list[0] = 'vegetables'

# Output
---------------------------------------------------------------------------
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

▶ Maintenant, exécutez l’extrait de code suivant pour vérifier que la fonction enumerate() fonctionne comme prévu 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}")

Comment utiliser la fonction enumerate() avec des chaînes Python

Vous pouvez également utiliser la fonction Python enumerate() pour parcourir les chaînes et accéder simultanément aux caractères et aux indices.

Voici un exemple.

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

# Output
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

D’après la sortie ci-dessus, nous voyons que les caractères ainsi que leurs indices (0-8) ont été imprimés.

Conclusion👩🏽‍💻

Voici un résumé de ce que vous avez appris.

  • Vous pouvez utiliser des boucles for pour accéder aux éléments et conserver un compteur ou une variable d’index distincts.
  • Si vous le souhaitez, vous pouvez utiliser la fonction range() pour obtenir les index valides et accéder aux éléments en les indexant dans la liste.
  • Comme méthode Pythonique recommandée, vous pouvez utiliser la fonction enumerate() de Python avec la syntaxe : enumerate(iterable). Par défaut, le décompte ou l’index commence à 0.
  • Vous pouvez spécifier la valeur de début personnalisée avec la syntaxe enumerate(iterable, start) pour obtenir l’index commençant à la valeur start et les éléments correspondants.
  • Vous pouvez utiliser la fonction enumerate lorsque vous travaillez avec des tuples, des chaînes, des dictionnaires et, en général, tout itérable Python.

J’espère que vous avez trouvé ce tutoriel sur la fonction enumerate() utile. Ensuite, apprenez à trouver l’index d’un élément dans les listes Python. Continuez à coder !