Python, comme tout langage de programmation, vient avec un ensemble de fonction natives inclues dans la techno. Parmi celles-ci, nous pouvons citer filter, eval, format, ou encore enumerate, qui nous intéresse ici.
Vous voulez apprendre à vous servir de cette fonction, utile dans beaucoup de cas d’utilisation ? Faisons le point dans cet article !
Qu’est-ce que la fonction enumerate de Python ? Définition
Quelques mots sur Python
Avant d’expliquer concrètement ce qu’est la fonction enumerate dans le langage Python, il est intéressant de faire un rapide point sur cette technologie.
Python est un langage open-source né en 1991. S’il n’a pas eu de succès instantané, il connait un véritable essor depuis 2018 : il est même premier dans le célèbre classement Tiobe, listant les langages de programmation les plus populaires !
La raison principale à ce succès est son utilisation omniprésente dans le monde de la Big Data et de l’intelligence artificielle.
L’univers des data sciences n’est cependant pas sa seule utilisation. Python est aussi présent dans le monde du développement web (back-end), ou encore dans celui des objets connectés.
Si vous voulez tout savoir sur Python, nous avons écrit un article dédié à ce langage !
Le besoin de l’enumerate
Après ce rapide résumé de Python, il est temps de passer à ce qui nous intéresse ici : sa fonction enumerate.
Si, comme dans tous les langages de programmation, Python peut nativement exécuter des boucles for, celles-ci ne répondent pas à tous les besoins.
Contrairement à d’autres technologies, les for, avec Python, ne permettent pas d’accéder à l’index de l’élément courant. Or, accéder à l’index peut être nécessaire, notamment pour exécuter des traitements différents en fonction de la position de l’élément dans le tableau parcouru.
S’il existe plusieurs moyens de contourner cette limite, cela nécessite du code supplémentaire, ce qui peut, en plus d’alourdir les sources existantes, provoquer des oublis, erreurs et bugs. Voici comment gérer les index manuellement :
- En utilisant une variable externe :
index = 0
for value in values:
print(index, value)
index += 1
# renverra :
0 a
1 b
2 c
- En utilisant les fonctions range() et len() :
for index in range(len(values)):
value = values[index]
print(index, value)
# renverra :
0 a
1 b
2 c
Comme nous le voyons, le code s’en voit alourdi ; il est moins lisible et donc susceptible de provoquer des erreurs lors de son écriture. Pour parer à cela, il existe donc la méthode enumerate.
La fonction enumerate
La fonction enumerate permet de garder la trace de l’index lors de l’itération dans un tableau. L’appliquer sur un tableau déjà existant renverra un objet itérable, contenant à la fois l’index et l’item. C’est ce qui est rapidement expliqué dans la documentation officielle de Python.
En voici un exemple :
for count, value in enumerate(values):
print(count, value)
# renverra :
0 a
1 b
2 c
Nous obtenons le même résultat que dans la section précédente, pour un code bien plus court et compréhensible.
Mieux encore, la fonction enumerate peut prendre un deuxième argument en paramètre, permettant de modifier l’index de départ :
for count, value in enumerate(values, start=1):
print(count, value)
# renverra :
1 a
2 b
3 c
Ici, nous avons donné l’argument ‘start=1’ en second paramètre de la méthode, pour lui indiquer de faire commencer l’index à 1, et non à 0, qui est le cas par défaut.
Les cas d’utilisation de la fonction enumerate avec Python
Nous avons vu comment fonctionne l’enumerate, et en quoi elle est intéressante. Mais quels en sont les utilisations concrètes ?
Faisons le tour des principaux cas qui pourraient vous amener à utiliser enumerate.
Exécuter un traitement différent en fonction de l’index
L’intérêt d’avoir accès à l’index de l’élément courant et de pouvoir appliquer un traitement différent en fonction du numéro de l’index.
Par exemple, on peut vouloir modifier l’élément si l’index est égal à 0, ou s’il est pair/impair.
Dans ce second cas, nous utiliserions l’enumerate dans une boucle for, avec la fonction native modulo. Voici une implémentation de ce cas d’utilisation, via une fonction qui ne retourne que les éléments pairs d’un tableau :
def elements_pairs(iterable):
"""Retourne du tableau ``iterable`` les éléments pairs"""
values = []
for index, value in enumerate(iterable, start=1):
if not index % 2:
values.append(value)
return values
Créer une barre de chargement
Garder la trace de l’index courant permet également de créer une barre de chargement. En connaissant la taille totale du tableau, et la position actuelle dans le for, il est en effet possible d’en récupérer le pourcentage, pour l’afficher à l’utilisateur.
Voici un exemple complet :
import time
def process_item(item):
# Simulate processing time
time.sleep(0.1)
return item * 2
items = [1, 2, 3, 4, 5]
for i, item in enumerate(items):
processed_item = process_item(item)
progress = i / len(items) * 100
loading_bar = '[' + '=' * int(progress / 10) + ' ' * (10 - int(progress / 10)) + ']'
print(f'{loading_bar} {progress:.1f}%')
# on obientra comme résultat :
[ ] 0.0%
[= ] 20.0%
[== ] 40.0%
[=== ] 60.0%
[==== ] 80.0%
[===== ] 100.0%
On simule ici un faux temps de chargement (via la fonction process_item), appelée à chaque itération du tableau items, tableau encapsulé dans l’enumerate. L’index i nous permet de garder la position courante dans le for (de 1 à 5), pour savoir exactement quel est le niveau de chargement actuel. Ainsi, il est possible d’afficher à l’utilisateur une barre de chargement.
Utiliser l’index pour créer des URL
Imaginons maintenant que nous ayons un site permettant d’uploader des images. Nous voulons que ces images soient ensuite listées sur une page, puis accessibles unitairement via des URL. Il est possible d’utiliser l’index fourni par enumerate pour construire ces URL :
import os
image_dir = "/path/to/images/"
image_ids = ["abc123", "def456", "ghi789"]
gallery_html = "<div class='gallery'>"
for i, image_id in enumerate(image_ids):
# Construct URL of image thumbnail
thumbnail_url = os.path.join(image_dir, f"{image_id}_thumb.jpg")
# Construct URL of larger image page
larger_image_url = f"/image/{i}/{image_id}"
# Add image HTML to gallery
gallery_html += f"<a href='{larger_image_url}' target='_blank'><img src='{thumbnail_url}'></a>"
gallery_html += "</div>"
Ici, l’ensemble du code sert à générer le contenu HTML qui sera affiché sur la page web. Sur la page en question, toutes les images seront listées, et cliquables. Pour lister ces images, le DOM HTML est construit via une boucle for.
Chaque image est encapsulée dans un lien <a>, qui, au clic, l’ouvrira en grand format. Pour construire l’URL qui mène à cette image, nous pouvons, comme dans l’exemple, utiliser l’index renvoyé par l’enumerate. Cela permet notamment de connaître la position, dans le tableau complet d’images, de celle sur laquelle l’utilisateur vient de cliquer.
Conclusion
Nous l’avons vu, la fonction enumerate en Python peut se révéler très utile pour le développeur freelance. Elle permet de garder facilement, lors d’une boucle for, la position actuelle de l’index, sans devoir passer par des fonctions plus complexes ou une implémentation manuelle.
Bien que l’utilisation de cette fonction ne soit pas obligatoire (nous n’avons pas toujours besoin de connaître l’index courant), elle peut se révéler très utile ! Lors de cas d’utilisation complexes, comme nous l’avons vu avec le dernier exemple, elle simplifie grandement l’écriture du code du développeur.
Aussi, si vous avez besoin d’accéder à l’index dans une boucle for, la fonction enumerate peut être la solution idéale !
