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

Ce tutoriel vous apprendra à utiliser le énumérer() fonction en Python.

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

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 Python. énumérer() fonction. Nous allons également coder des exemples en cours de route.

Commençons.

How to Iterate Using for Loop in 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 le for loop 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éder 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 un index variable, 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 for boucle est en conjonction avec le range() fonction. Nous en apprendrons davantage dans la section suivante.

How to Use range() Function to Access Index

Fonction intégrée len() de Python renvoie la longueur de tout objet Python. Vous pouvez donc appeler le len() fonctionner avec shopping_list l'argument pour obtenir la longueur de shopping_list (ce qui est 5, dans ce cas).

len(shopping_list)
# Output: 5

Les range() La fonction renvoie un objet de plage que vous pouvez ensuite utiliser en boucle. Lorsque vous faites une boucle range(stop), vous obtenez les indices 0, 1, 2,…, stop-1.

En définissant stop = len(list), vous pouvez obtenir la liste des index valides. Donc en utilisant le range() fonction, 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.

Syntax of Python enumerate() Function

Python énumérer() 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 une conditions paramètre, 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 le enumerate() fonctionner avec shopping_list et il renvoie un objet d'énumération, comme indiqué dans la cellule de code ci-dessous.

enumerate(shopping_list)
<enumerate at 0x7f91b4240410>

Vous ne pouvez pas parcourir le enumerate objet. Convertissons donc le enumerate objet dans 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 la enumerate l'objet est d'appeler le fonction suivante() les enumerate objet comme argument. En Python, le next() La fonction renvoie l'élément suivant d'un itérateur.

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

Attribuons l'objet énumération à la variable shopping_list_enum.

shopping_list_enum = enumerate(shopping_list)

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

Lorsque vous continuez à passer d'autres appels vers le next() fonction, 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 next() fonction après avoir accédé à tous les éléments et atteint la fin de la liste ? Vous obtenez un StopIteration Error.

next(shopping_list_enum)
# ---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-16-4220f68f6c7e> in <module>()
----> 1 next(shopping_list_enum)

StopIteration:

Les enumerate() La fonction renvoie les indices et éléments successifs uniquement lorsque cela est nécessaire et ne sont pas calculés à l'avance. Dans Projets Python où vous devez prendre en compte l'efficacité de la mémoire, vous pouvez essayer d'utiliser le enumerate() fonction lorsque vous devez parcourir de grands itérables.

Python enumerate() Function Examples

Maintenant que nous avons appris la syntaxe pour utiliser le enumerate() fonction, 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 , 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.

How to enumerate() with Custom Start Value

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

Dans le shopping_list exemple, 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 seconde argumentation positionnelle.

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 le enumerate() fonction avec des listes Python. Vous pouvez également utiliser la fonction énumérer pour parcourir Chaînes Python, dictionnaires et tuples.

How to Use enumerate() Function with Python Tuples

Supposer shopping_list est un tuple. En Python, les tuples sont également des collections, similaires aux listes Python, mais ils sont immuable. Par conséquent, vous ne pouvez pas les modifier et essayer de le faire entraînera une erreur.

L'extrait de code suivant s'initialise shopping_list comme 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 le enumerate() la fonction 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}")

How to Use enumerate() Function with Python Strings

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 pour le des boucles pour accéder aux éléments et conserver un compteur ou une variable d'index distincts.
• Si vous le souhaitez, vous pouvez utiliser le intervalle() pour obtenir les index valides et accéder aux éléments en les indexant dans la liste.
• En tant que méthode Pythonic recommandée, vous pouvez utiliser Python énumérer() fonction avec la syntaxe : énumérer (itérable). Par défaut, le décompte ou l'index commence à 0.
• Vous pouvez spécifier la coutume Commencez valeur avec la syntaxe énumérer (itérable, commencer) pour obtenir l'indice à partir de la valeur Commencez 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 !