Utiliser la fonction Enumerate en Python pour créer des boucles avec des compteurs

Cet article expliquera l'utilisation de la fonction « énumérer » disponible dans la bibliothèque de modules standard de Python. La fonction d'énumération vous permet d'attribuer un "index" ou un "compte" aux éléments de n'importe quel objet itérable. Vous pouvez ensuite implémenter une logique supplémentaire sur eux car vous aurez accès aux deux valeurs et à un nombre mappé dessus.

Syntaxe et exemple de base

Si vous avez utilisé une boucle "for" dans d'autres langages de programmation, en particulier le langage "C" et d'autres langages ayant une syntaxe de style "C", vous avez peut-être spécifié un index de départ dans la boucle. Pour référence, voici à quoi ressemble une boucle "for" en "C" et dans d'autres langages ayant une syntaxe similaire :

pour (int i = 0; i < 10; i++)

printf("%d\n", i);

L'instruction de boucle initialise une variable ayant une valeur de zéro, vérifie qu'elle est inférieure à un seuil et l'incrémente d'un compte après avoir évalué la logique à l'intérieur du bloc de boucle (si la condition d'arrêt est remplie). De cette façon, vous pouvez utiliser un index et l'affecter à tous les objets référencés dans votre bloc de boucle. En comparaison, voici à quoi ressemble une boucle for avec le même résultat en Python :

pour i dans la plage (0, 10) :
imprimer (i)

La fonction "range" en Python vous permet de spécifier une séquence de plage de nombres qui a un pas par défaut de 1. Vous pouvez modifier la valeur du pas en fournissant un troisième argument. Le deuxième argument de la fonction « range » est utilisé pour définir le seuil de la condition d'arrêt. Les deux exemples de code produisent la sortie suivante :

0
1
2
3
4
5
6
7
8
9

Ces boucles fonctionnent bien si vous souhaitez simplement générer une séquence de nombres et les associer à une logique à l'intérieur de l'instruction de boucle. Cependant, vous devrez peut-être utiliser une autre boucle imbriquée ou utiliser la fonction « rendement » sur n'importe quel type itérable pour leur attribuer une sorte de nombre traçable. La méthode « enumerate » facilite l'attribution d'index aux itérables dans une seule instruction, éliminant ainsi le besoin d'exécuter plusieurs boucles imbriquées. Jetez un œil à cet exemple de code :

nombres = ["zéro", "un", "deux", "trois", "quatre", "cinq"]
enumerated_numbers = énumérer (nombres)
pour l'index, élément dans enumerated_numbers :
imprimer (index, élément)

La première instruction définit une nouvelle variable appelée « nombres » et lui attribue un itérable (type liste). La deuxième instruction montre l'utilisation de la fonction "énumérer" où vous lui fournissez un itérable comme argument obligatoire. La troisième instruction convertit la variable "enumerated_numbers" en un objet de type liste. Par défaut, la fonction « énumérer » génère un objet de type « énumérer » et non un type itérable, vous devez donc le convertir. Après avoir exécuté l'exemple de code mentionné ci-dessus, vous devriez obtenir le résultat suivant :

[(0, 'zéro'), (1, 'un'), (2, 'deux'), (3, 'trois'), (4, 'quatre'), (5, 'cinq')]

La fonction « énumérer » attribue un nombre à chaque élément dans un type itérable et crée des tuples ayant des valeurs appariées. Par défaut, le décompte commence à partir de zéro.

Maintenant que vous avez attribué un numéro à chaque élément d'un type itérable, vous pouvez facilement le parcourir sans écrire d'instructions imbriquées :

nombres = ["zéro", "un", "deux", "trois", "quatre", "cinq"]
enumerated_numbers = énumérer (nombres)
pour l'index, élément dans enumerated_numbers :
imprimer (index, élément)

L'exemple de code spécifié ci-dessus produira la sortie suivante :

0 zéro
1 un
2 deux
3 trois
4 quatre
5 cinq

Vous pouvez raccourcir le code en utilisant la fonction « énumérer » en ligne, comme indiqué dans l'exemple ci-dessous :

nombres = ["zéro", "un", "deux", "trois", "quatre", "cinq"]
pour l'index, élément dans énumérer (nombres):
imprimer (index, élément)

Utiliser Enumerate avec un index de départ différent

La fonction « énumérer » prend un argument facultatif où vous pouvez spécifier un index de départ. Par défaut, c'est zéro, mais vous pouvez le changer en utilisant l'argument « start » :

nombres = ["un", "deux", "trois", "quatre", "cinq"]
pour l'index, élément dans énumérer (nombres, début = 1) :
imprimer (index, élément)

Dans la deuxième instruction, l'argument "start=1" est utilisé pour changer le point de départ. Après avoir exécuté l'exemple de code spécifié ci-dessus, vous devriez obtenir le résultat suivant :

1 un
2 deux
3 trois
4 quatre
5 cinq

Affectation d'un index avec des étapes

Dans la première section de cet article, la syntaxe de la boucle "for" en langage "C" est affichée où vous pouvez définir des étapes entre chaque compte ou index ultérieur. La fonction « énumérer » en Python n'a pas un tel argument disponible, vous ne pouvez donc pas spécifier une étape entre les comptes. Vous pouvez en effet écrire votre propre logique pour implémenter des étapes à l'intérieur du bloc de boucle énuméré "for". Cependant, il existe un moyen d'implémenter des étapes personnalisées en écrivant un code minimal. L'exemple suivant montre la mise en œuvre des étapes à l'aide des fonctions « zip » et « plage » :

nombres = ["zéro", "deux", "quatre", "six"]
pour l'index, élément dans zip(plage (0, 7, 2), nombres) :
imprimer (index, élément)

La fonction "zip" permet de créer des paires en récupérant des éléments ayant le même index à partir de deux ou plusieurs itérables. Ainsi, la fonction "zip" récupère ici un élément de l'itérable renvoyé par la fonction "range (0, 7, 2)" et un autre élément de la liste "numbers", puis les associe en un tuple. Le résultat final est une implémentation identique à la fonction « énumérer » mais avec des étapes personnalisées spécifiées comme troisième argument dans la fonction « plage (0, 7, 2) » (2 dans ce cas). Après avoir exécuté l'exemple de code spécifié ci-dessus, vous devriez obtenir le résultat suivant :

0 zéro
2 deux
4 quatre
6 six

Conclusion

La fonction « énumérer » en Python vous permet d'écrire du code concis en attribuant une séquence de nombres aux éléments d'un objet itérable. C'est vraiment utile si vous voulez garder une trace de l'index des éléments à l'intérieur d'un type itérable. Si vous souhaitez « énumérer » les types itérables avec des étapes personnalisées, utilisez la fonction « zip » expliquée dans le dernier exemple.