Tutoriel sur enumerate en Python

Dans ce tutoriel, nous verrons ce qu’est la fonction enumerate() en Python, quand l’utiliser, quel type d’objet elle renvoie, sa syntaxe et son fonctionnement. Nous examinerons ensuite des exemples d’énumération de différents types d’objets en Python, les alternatives à enumerate(), et pourquoi elles sont moins adaptées pour le même usage.

Qu’est-ce que enumerate en Python et quand l’utiliser ?

La fonction enumerate() est une fonction native de Python qui prend un itérable (une collection d’éléments ou tout autre objet Python supportant l’itération, comme des tuples, des listes, des ensembles ou des chaînes de caractères), parcourt ses éléments en coulisse et renvoie un objet enumerate. Autrement dit, cette fonction associe un compteur incrémenté de 1 à chaque élément d’un itérable et nous aide à suivre les itérations lors d’une boucle sur cet objet. Une fois l’objet enumerate créé, on peut le convertir en liste, en tuple ou en dictionnaire (grâce aux fonctions list(), tuple() ou dict() respectivement), ou bien itérer directement dessus pour accéder à la fois aux éléments et à leur indice correspondant.

Utiliser enumerate() est intéressant en termes d’efficacité mémoire et calculatoire par rapport à des for-loops classiques, car elle renvoie d’un seul coup l’indice et l’élément correspondant.

Syntaxe

La syntaxe d’enumerate() est très simple :

enumerate(iterable, start=0)

Ici, iterable est l’objet itérable que nous souhaitons énumérer, et start est un paramètre optionnel qui définit l’indice de départ du compteur (par défaut, l’indexation Python commence à 0).

Notez qu’appliquer enumerate() à un itérable ne modifie pas l’objet initial. L’objet enumerate obtenu doit être affecté à une variable si l’on veut le réutiliser.

Voyons maintenant comment cette fonction se comporte avec différents types d’itérables Python.

Enumérer une liste

Commençons par appliquer enumerate() à une liste Python :

drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
enumerated_drinks = enumerate(drinks)
print(type(enumerated_drinks))
print(enumerated_drinks)

Sortie :

<class 'enumerate'>
<enumerate object at 0x000002DC3A1145C0>

Le type de l’objet obtenu est enumerate et, en l’affichant, nous confirmons simplement son type et son emplacement en mémoire. Essayons d’accéder au premier élément de cet objet comme on le ferait avec une liste ou un tuple Python :

print(enumerated_drinks[0])

Sortie :

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_5948/1233607596.py in <module>
----> 1 print(enumerated_drinks[0])

TypeError: 'enumerate' object is not subscriptable

Nous obtenons une erreur indiquant que les composants d’un objet enumerate ne sont pas accessibles de cette façon. Pour y parvenir, nous devons le convertir en liste, tuple ou dictionnaire, ou itérer directement sur l’objet enumerate. Convertissons notre objet enumerate en liste :

list_enumerated_drinks = list(enumerated_drinks)
print(list_enumerated_drinks)

Sortie :

[(0, 'tea'), (1, 'coffee'), (2, 'cappuccino'), (3, 'lemonade')]

On voit clairement la structure interne de la liste obtenue : chaque élément est un tuple de 2 éléments, le premier étant l’indice dans la liste d’origine et le second l’élément lui‑même. On peut utiliser l’indexation classique pour accéder aux éléments de cette liste :

print(list_enumerated_drinks[0])
print(list_enumerated_drinks[0][1])

Sortie :

(0, 'tea')
tea

Essayons maintenant de convertir en tuple un objet enumerate créé à partir de la liste initiale. Cette fois, nous allons définir le paramètre optionnel start à 1 :

tuple_enumerated_drinks = tuple(enumerate(drinks, start=1))
print(tuple_enumerated_drinks)

Sortie :

((1, 'tea'), (2, 'coffee'), (3, 'cappuccino'), (4, 'lemonade'))

La structure interne du tuple ci‑dessus est identique à celle de la liste créée précédemment. Toutefois, nous avons démarré le comptage à 1 pour une numérotation plus « naturelle » que l’indexation Python à partir de 0.

Un aspect intéressant d’un objet enumerate mérite d’être mentionné ici : la fonction next(). Recréons l’objet enumerated_drinks et testons‑la :

enumerated_drinks = enumerate(drinks)
print(next(enumerated_drinks))
print(next(enumerated_drinks))
print(next(enumerated_drinks))
print(next(enumerated_drinks))
print(next(enumerated_drinks))

Sortie :

(0, 'tea')
(1, 'coffee')
(2, 'cappuccino')
(3, 'lemonade')

---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_5948/330134057.py in <module>
      4 print(next(enumerated_drinks))
      5 print(next(enumerated_drinks))
----> 6 print(next(enumerated_drinks))

StopIteration: 

Comme on le voit, chaque appel renvoie l’élément suivant de l’objet enumerate (et l’on confirme à nouveau que chaque élément est un tuple à 2 composantes contenant la paire indice‑élément). Une fois tous les éléments consommés, l’objet enumerate est épuisé et un nouvel appel à next() déclenche une erreur StopIteration. En effet, si nous essayons maintenant de convertir cet objet enumerate en liste, elle sera vide :

print(list(enumerated_drinks))

Sortie :

[]

Cela signifie qu’à chaque appel de next() sur un objet enumerate, un élément est retiré de l’objet : il rétrécit donc à chaque fois, jusqu’à épuisement total. Nous reverrons cette propriété lors de l’utilisation de for-loops.

Pour approfondir les listes et d’autres notions de base de Python, suivez le cours Introduction to Python de DataCamp.

Enumérer un tuple

L’utilisation d’enumerate() sur un tuple est identique à celle sur une liste :

drinks = ('tea', 'coffee', 'cappuccino', 'lemonade')
enumerated_drinks = enumerate(drinks)
print(enumerated_drinks)

Sortie :

<enumerate object at 0x000002DC3A098D40>

Nous obtenons à nouveau un objet enumerate dont les éléments ne sont pas accessibles par indexation classique. Transformons‑le cette fois en dictionnaire :

dict_enumerated_drinks = dict(enumerated_drinks)
print(dict_enumerated_drinks)

Sortie :

{0: 'tea', 1: 'coffee', 2: 'cappuccino', 3: 'lemonade'}

Chaque paire clé:valeur du dictionnaire représente la paire indice‑élément correspondante. On peut accéder aux valeurs de façon Pythonique :

print(dict_enumerated_drinks[0])
print(dict_enumerated_drinks[3])

Sortie :

tea
lemonade

Pour aller plus loin avec les dictionnaires Python et pandas, explorez le cours Intermediate Python.

Enumérer une chaîne de caractères

Les chaînes Python étant des séquences de caractères et donc des objets itérables, on peut également créer un objet enumerate pour une chaîne :

enumerated_hello_world = enumerate('Hello, World!', start=10)
print(enumerated_hello_world)

Sortie :

<enumerate object at 0x000002DC3A145C40>

Comme précédemment, convertissons cet objet en liste :

list_enumerated_hello_world = list(enumerated_hello_world)
print(list_enumerated_hello_world)

Sortie :

[(10, 'H'), (11, 'e'), (12, 'l'), (13, 'l'), (14, 'o'), (15, ','), (16, ' '), (17, 'W'), (18, 'o'), (19, 'r'), (20, 'l'), (21, 'd'), (22, '!')]

On retrouve les tuples à 2 éléments : le premier correspond à l’indice du caractère (ici en commençant à 10) et le second au caractère lui‑même. Les espaces et signes de ponctuation sont également comptés.

Recréons enumerated_hello_world, cette fois sans start=10, et appliquons next() dessus :

enumerated_hello_world = enumerate('Hello, World!')
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
print(next(enumerated_hello_world))
​
# Creating a list from the remaining enumerate object
print(list(enumerated_hello_world))

Sortie :

(0, 'H')
(1, 'e')
(2, 'l')
(3, 'l')
(4, 'o')
(5, ',')
[(6, ' '), (7, 'W'), (8, 'o'), (9, 'r'), (10, 'l'), (11, 'd'), (12, '!')]

À la dernière ligne, nous cessons d’appeler next() et convertissons l’objet enumerated_hello_world en liste. La liste résultante contient les caractères restants de l’objet enumerate initial après plusieurs appels à next().

Enumérer avec une boucle for

Voyons enfin comment enumerate() fonctionne avec une boucle for :

for item in enumerate(['tea', 'coffee', 'cappuccino', 'lemonade']):
  print(item)

Sortie :

(0, 'tea')
(1, 'coffee')
(2, 'cappuccino')
(3, 'lemonade')

À chaque itération, le tuple (indice, élément) est renvoyé, comme avec next(). Même si cela ne se voit pas directement ici, l’objet enumerate perd également ses éléments un à un à chaque itération. Pour le démontrer, réécrivons le code et regardons la longueur de l’objet restant après la boucle :

drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
enumerated_drinks = enumerate(drinks)
​
for item in enumerated_drinks:
  print(item)
 
print(list(enumerated_drinks))

Sortie :

(0, 'tea')
(1, 'coffee')
(2, 'cappuccino')
(3, 'lemonade')
[]

Comme avec next(), itérer sur un objet enumerate l’épuise progressivement.

Revenons néanmoins au code précédent. Comment accéder séparément aux deux éléments de chaque tuple ? Il suffit d’ajouter une variable d’itération et de déballer les tuples :

for count, drink in enumerate(['tea', 'coffee', 'cappuccino', 'lemonade']):
  print(count, drink)

Sortie :

0 tea
1 coffee
2 cappuccino
3 lemonade

Ici, nous renvoyons deux variables pour chaque tuple : l’indice et l’élément.

Sachez que nous pouvons obtenir le même résultat sans enumerate(). Par exemple, en définissant un compteur en dehors de la boucle et en l’incrémentant de 1 à chaque itération :

count = 0
for drink in ['tea', 'coffee', 'cappuccino', 'lemonade']:
  print(count, drink)
  count += 1

Sortie :

0 tea
1 coffee
2 cappuccino
3 lemonade

Autre option : combiner range() et len() sur une liste (ou un tuple, une chaîne, etc.) prédéfinie :

drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
for count in range(len(drinks)):
  print(count, drinks[count])

Sortie :

0 tea
1 coffee
2 cappuccino
3 lemonade

Dans ces deux alternatives, on peut aussi démarrer le compteur à une autre valeur que zéro :

count = 1
for drink in ['tea', 'coffee', 'cappuccino', 'lemonade']:
  print(count, drink)
  count += 1
​
print('\n')
 
drinks = ['tea', 'coffee', 'cappuccino', 'lemonade']
for count in range(len(drinks)):
  print(count + 1, drinks[count])

Sortie :

1 tea
2 coffee
3 cappuccino
4 lemonade


1 tea
2 coffee
3 cappuccino
4 lemonade

Cependant, comparées à enumerate(), ces deux approches sont plus lourdes, plus sujettes aux erreurs (p. ex., oublier de mettre à jour le compteur) et nécessitent plus de code. Utiliser enumerate() reste donc l’approche la plus Pythonique dès que l’on a besoin d’accéder à la fois à l’indice et à l’élément à chaque itération.

Conclusion

Dans ce tutoriel, nous avons découvert de nombreux aspects de la fonction enumerate() en Python : ses usages, ses alternatives possibles, et pourquoi elle s’avère au final plus efficace que ces dernières. La fonction enumerate() n’est pas toujours connue des débutants, et même des développeurs confirmés peuvent passer à côté de cet outil très pratique.

Pour en savoir plus sur enumerate(), consultez le cours Python Data Science Toolbox (Part 2) qui explore en détail les itérateurs et itérables, avec des exercices interactifs pour pratiquer. Par ailleurs, si vous souhaitez maîtriser d’autres concepts Python, découvrez Learn Python with DataCamp, qui propose divers parcours de compétences et de carrière, des fiches mémo, des tutoriels, des certifications Python et des tests d’évaluation.