Fonction Python enumerate(), expliquée avec des exemples
Par
Bala Priya C
Ce tutoriel vous apprendra à utiliser la fonction enumerate() en Python.
La fonction enumerate() de Python fournit une syntaxe concise pour accéder aux éléments d'une table itérative ainsi qu'à leurs indices.
Nous commencerons par revoir comment accéder aux éléments et aux indices à l'aide d'une simple boucle, puis nous apprendrons la syntaxe de la fonction Python enumerate(). Nous donnerons également des exemples de code en cours de route.
Commençons.
Comment itérer en utilisant la boucle for en Python
Tout objet Python sur lequel vous pouvez itérer et accéder aux éléments individuels un par un est appelé 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 la cellule de code ci-dessous.
shopping_list = ["fruits", "biscuits", "céréales", "barres protéinées", "post-it"]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> :
# faire quelque chose sur l'élément
# élément : variable de bouclage
# <itérable> : tout itérable Python : liste, tuple, dictionnaire, chaîne de caractères, etc.À l'aide de cette syntaxe, parcourons en boucle shopping_list et accédons aux différents éléments.
for item in shopping_list :
print(item)
# Output
fruits
cookies
cereals
protein bars
post-it notesCette construction vous permet d'accéder directement aux éléments. Cependant, vous pouvez parfois avoir besoin d'accéder à l'index des éléments, en plus des éléments eux-mêmes.
Vous pouvez utiliser une variable index, que vous pouvez incrémenter à l'intérieur du 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, céréales
index:3, barres protéinées
index:4, post-it notesMais cette méthode n'est pas la plus efficace. Si vous n'oubliez 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}")
# pas de mise à jour de l'index dans le corps de la boucle
# l'index n'est jamais mis à jour et est toujours 0
# Sortie
index:0, fruits
index:0, cookies
index:0, céréales
index:0, barres protéinées
index:0, post-it notesUn autre modèle courant d'utilisation de la boucle for est l'association avec la fonction range(). Nous verrons cela 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 n'importe quel objet Python. Vous pouvez donc appeler la fonction len() avec shopping_list comme argument pour obtenir la longueur de shopping_list (qui est de 5, dans ce cas).
len(shopping_list)
# Sortie : 5La fonction range() renvoie un objet range que vous pouvez ensuite utiliser pour effectuer des boucles. Lorsque vous bouclez sur range(stop), 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'indice 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 : céréales
index:3, item : barres protéinées
index:4, item : post-it notesCependant, ce n'est pas la méthode recommandée par Python pour accéder simultanément aux indices et aux éléments.
Syntaxe de la fonction Python enumerate()
La fonction Python enumerate() vous permet d'accéder aux éléments ainsi qu'à leurs indices en utilisant la syntaxe générale suivante :
enumerate(<iterable>, start = 0)Dans la syntaxe ci-dessus :
<iterable>est un paramètre obligatoire, qui peut être n'importe quel itérable Python, tel qu'une liste ou un tuple.- start est un paramètre optionnel qui contrôle l'indice auquel le comptage commence. Si vous ne précisez pas la valeur de start, elle est fixée par défaut à zéro.
Vous pouvez maintenant appeler la fonction enumerate() avec shopping_list et elle renvoie un objet énuméré, comme le montre la cellule de code ci-dessous.
enumerate(shopping_list)
<enumerate at 0x7f91b4240410>Vous ne pouvez pas faire de boucle dans l'objet énumération. Convertissons donc l'objet énumération en une liste Python.
list(enumerate(shopping_list))
# Output
[(0, 'fruits'),
(1, 'cookies'),
(2, 'céréales'),
(3, 'barres protéinées'),
(4, 'post-it notes')]Une autre méthode pour accéder aux éléments de l'objet énumération consiste à appeler la fonction next() avec l'objet énumération comme argument. En Python, la fonction next() renvoie l'élément suivant d'un itérateur.
En interne, la fonction next() appelle la méthode __next__ de l'objet itérateur pour récupérer les éléments successifs.
Affectons l'objet é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').
Si vous continuez à appeler 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, 'céréales')
next(shopping_list_enum)
# (3, 'barres protéinées')
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 d'arrêt d'itération.
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 les é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 avez besoin de boucler sur de grandes iterables.
Exemples de la fonction Python enumerate()
Maintenant que nous avons appris la syntaxe d'utilisation de la fonction enumerate(), modifions la boucle for que nous avions précédemment.
D'après la section précédente, nous savons que le passage en boucle de l'objet enumerate renvoie un tuple contenant l'index et l'élément. Nous pouvons décomposer 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 notesVoyons maintenant 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. Cependant, si vous souhaitez que les indices soient lisibles par l'homme, en commençant par 1 ou tout autre indice de votre choix, vous pouvez spécifier une valeur de départ personnalisée.
Dans l'exemple de 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:céréales
index:4, item:barres protéinées
index:5, item:post-it notesCependant, lorsque vous spécifiez la valeur de départ personnalisée, vous devez vous assurer qu'elle constitue le deuxième argument de position.
Si vous intervertissez par erreur l'ordre de l'itérable et de la valeur de départ, vous rencontrerez une erreur, comme l'explique 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 integerPour éviter ce type d'erreur, vous pouvez spécifier start en tant que 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:céréales
index:4, item:barres protéinées
index:5, item:post-it notesJusqu'à présent, vous avez appris à utiliser la fonction enumerate() avec les listes Python. Vous pouvez également utiliser la fonction enumerate pour parcourir des chaînes de caractères, des dictionnaires et des tuples Python.
Comment utiliser la fonction enumerate() avec les tuples Python ?
Supposons que shopping_list soit un tuple. En Python, les tuples sont également des collections, semblables aux listes Python, mais ils sont immuables. Par conséquent, vous ne pouvez pas les modifier, et toute tentative en ce sens entraînera une erreur.
L'extrait de code suivant initialise shopping_list en tant que tuple.
shopping_list = ("fruits", "cookies", "céréales", "barres protéinées", "post-it")
type(shopping_list)
# TupleSi vous essayez de modifier le premier élément du tuple, vous obtiendrez une erreur car un tuple Python est une collection immuable.
shopping_list<x>[0]</x> = 'vegetables'
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-2-ffdafa961600> in <module>()
---->
1 shopping_list<x>[0]</x> = 'vegetables'
TypeError : 'tuple' object does not support item assignmentexécutez maintenant l'extrait de code suivant pour vérifier que la fonction enumerate() fonctionne comme prévu avec les tuples.
shopping_list = ("fruits", "biscuits", "céréales", "barres protéinées", "post-it")
for index, item in enumerate(shopping_list) :
print(f "index:{index}, item:{item}")Comment utiliser la fonction enumerate() avec les chaînes de caractères Python ?
Vous pouvez également utiliser la fonction Python enumerate() pour parcourir en boucle des chaînes de caractères 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 : yLa sortie ci-dessus montre que les caractères et leurs indices (0-8) ont été imprimés.
Conclusion👩🏽💻
Voici un résumé de ce que vous avez appris.
- Vous pouvez utiliser des boucles pour verser accéder aux éléments et maintenir un compteur séparé ou une variable d'index.
- Si vous le souhaitez, vous pouvez utiliser la fonction range() pour obtenir les indices valides et accéder aux éléments en indexant la liste.
- Comme méthode recommandée par Python, vous pouvez utiliser la fonction Python enumerate() avec la syntaxe : enumerate(iterable). Par défaut, le compte ou l'index commence à 0.
- Vous pouvez spécifier une valeur de départ personnalisée avec la syntaxe suivante : 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, avec n'importe quel itérable Python.
J'espère que ce tutoriel sur la fonction enumerate() vous a été utile. Ensuite, apprenez à trouver l'index d'un élément dans les listes Python. Continuez à coder !
-
Bala Priya CAuteur
