Python enumerate() Function, Explained with Examples

On this tutorial you’ll learn to use the sum up() perform in Python.

The enumerate() perform in Python supplies a concise syntax to entry the objects in an iterable type together with their indices.

We’ll begin by taking a look at how you can entry objects and indices utilizing easy looping, then transfer on to studying Python’s syntax sum up() perform. We’ll additionally code samples alongside the way in which.

Let’s begin.

iterate utilizing for Loop in Python

Any Python object you could iterate over and entry the person objects, separately, known as an iterable. Due to this fact, Python lists, tuples, dictionaries, and strings are all iterables.

python enumerate img

Let’s take an instance of a purchasing listing outlined within the code cell under.

shopping_list = ["fruits","cookies","cereals","protein bars","post-it notes"]

In Python you should use the for loop to undergo every iterable loop. The syntax to do that is as follows:

for merchandise in <iterable>:
    # do one thing on merchandise

# merchandise: looping variable
# <iterable>: any Python iterable: listing, tuple, dictionary, string, and so forth.

Now, utilizing this syntax, let’s stroll by shopping_list and entry the person objects.

for merchandise in shopping_list:
  print(merchandise)

# Output
fruits
cookies
cereals
protein bars
post-it notes

This development permits you to entry the objects immediately. Nevertheless, along with the objects themselves, you may additionally want entry to the index of the objects.

You should use one index variable, which you’ll be able to increment contained in the loop, as proven under:

index = 0
for merchandise in shopping_list:
  print(f"index:{index}, {merchandise}")
  index += 1

# Output
index:0, fruits
index:1, cookies
index:2, cereals
index:3, protein bars
index:4, post-it notes

However this isn’t probably the most environment friendly methodology. In the event you do not bear in mind to lift the index, your code will not work as anticipated.

index = 0
for merchandise in shopping_list:
  print(f"index:{index}, {merchandise}")
  # no replace of index inside loop physique
  # index is rarely up to date and is all the time 0

# Output
index:0, fruits
index:0, cookies
index:0, cereals
index:0, protein bars
index:0, post-it notes

One other frequent sample when utilizing the for loop is at the side of the vary() perform. We’ll study that within the subsequent part.

use the vary() perform to entry the index

Python’s built-in len() perform returns the size of every Python object. So you’ll be able to name the len() perform alongside shopping_list the argument to get the size of the shopping_list (on this case it’s 5).

len(shopping_list)
# Output: 5

The vary() perform returns a scope object you could then use in a loop. Once you stroll by vary(cease)you get the indices 0, 1, 2,…, stop-1.

By setting cease = len(listing), you will get the listing of legitimate indices. So by utilizing the vary() perform you’ll be able to entry the index and its entry, as proven under.

for index in vary(len(shopping_list)):
  print(f"index:{index}, merchandise: {shopping_list[index]}")

# Output
index:0, merchandise: fruits
index:1, merchandise: cookies
index:2, merchandise: cereals
index:3, merchandise: protein bars
index:4, merchandise: post-it notes

Nevertheless, this isn’t the really useful Pythonic technique to entry each indices and objects on the similar time.

Python perform syntax enumerate().

Pythons sum up() The perform permits you to entry the objects together with their indexes utilizing the next frequent syntax:

enumerate(<iterable>, begin = 0)

Within the syntax above:

  • <iterable> is a required parameter, and it may be any Python iterable, akin to a listing or tuple.
  • begin is an non-compulsory parameter that determines the index at which counting begins. If you don’t specify the worth of begin, it defaults to zero.

Now you can name the enumerate() perform alongside shopping_list and it returns an enumerate object, as proven within the code cell under.

enumerate(shopping_list)
<enumerate at 0x7f91b4240410>

You can’t stroll by the loop enumerate object. So let’s the enumerate object in a Python listing.

listing(enumerate(shopping_list))

# Output
[(0, 'fruits'),
 (1, 'cookies'),
 (2, 'cereals'),
 (3, 'protein bars'),
 (4, 'post-it notes')]

One other methodology of accessing the objects from the enumerate object is to name the subsequent() perform with the enumerate object as an argument. In Python, the subsequent() perform returns the subsequent merchandise of an iterator.

Inside is the subsequent() perform works by calling the __next__ methodology on the iterator object to retrieve the consecutive objects.

Let’s assign the enumerate object to the variable shopping_list_enum.

shopping_list_enum = enumerate(shopping_list)

Once you name for the primary time subsequent() of shopping_list_enumyou get index zero and the merchandise at index 0: the tuple (0, 'fruits').

In the event you proceed calling the subsequent() perform, you’ll get the sequential objects together with their indexes as described under.

subsequent(shopping_list_enum)
# (0, 'fruits')
subsequent(shopping_list_enum)
# (1, 'cookies')
subsequent(shopping_list_enum)
# (2, 'cereals')
subsequent(shopping_list_enum)
# (3, 'protein bars')
subsequent(shopping_list_enum)
# (4, 'post-it notes')

What occurs once you name subsequent() perform after you will have opened all objects and reached the tip of the listing? You get one StopIteration Error.

subsequent(shopping_list_enum)
# ---------------------------------------------------------------------------
StopIteration                             Traceback (most up-to-date name final)
<ipython-input-16-4220f68f6c7e> in <module>()
----> 1 subsequent(shopping_list_enum)

StopIteration:

The enumerate() perform returns the sequential indices and objects solely when wanted and aren’t calculated upfront. In Python initiatives the place you have to take into account reminiscence effectivity, you’ll be able to attempt the enumerate() function when you have to undergo massive iterables.

Python enumerate() Perform Examples

Now that we have realized the syntax to make use of the enumerate() perform, let’s change the for loop we had earlier than.

From the earlier part, we all know that iterating by the enumerate object returns a tuple containing the index and the merchandise. We are able to unpack this tuple into two variables: index And merchandise.

for index, merchandise in enumerate(shopping_list):
  print(f"index:{index}, merchandise:{merchandise}")

# Output
index:0, merchandise:fruits
index:1, merchandise:cookies
index:2, merchandise:cereals
index:3, merchandise:protein bars
index:4, merchandise:post-it notes

Subsequent, let’s have a look at how you can specify a customized begin worth.

enumerate() with customized preliminary worth

Python follows null indexing, so the begin worth is 0 by default. Nevertheless, if you happen to want the indexes in human readable type (beginning with 1 or some other index of your alternative), you’ll be able to specify a customized index begin worth.

Within the shopping_list For instance, if you wish to begin counting from 1, set begin = 1.

for index, merchandise in enumerate(shopping_list,1):
  print(f"index:{index}, merchandise:{merchandise}")

# Output
index:1, merchandise:fruits
index:2, merchandise:cookies
index:3, merchandise:cereals
index:4, merchandise:protein bars
index:5, merchandise:post-it notes

Nevertheless, once you specify the customized begin worth, ensure you specify it as second positional argument.

In the event you by chance change the order of the iterable and the beginning worth, you’ll run into an error, as defined within the code cell under.

for index, merchandise in enumerate(1,shopping_list):
  print(f"index:{index}, merchandise:{merchandise}")

# Output
---------------------------------------------------------------------------
TypeError                                 Traceback (most up-to-date name final)
<ipython-input-12-5dbf7e2749aa> in <module>()
----> 1 for index, merchandise in enumerate(1,shopping_list):
      2   print(f"index:{index}, merchandise:{merchandise}")

TypeError: 'listing' object can't be interpreted as an integer

To keep away from such errors, you’ll be able to specify it begin as a key phrase argument, as proven under.

for index, merchandise in enumerate(shopping_list, begin = 1):
  print(f"index:{index}, merchandise:{merchandise}")

# Output
index:1, merchandise:fruits
index:2, merchandise:cookies
index:3, merchandise:cereals
index:4, merchandise:protein bars
index:5, merchandise:post-it notes

To date you will have realized how you can use the enumerate() perform with Python lists. You can too use the enumerate perform to iterate by Python strings, dictionaries, and tuples.

use the enumerate() perform with Python Tuples

Suppose shopping_list is a tuple. In Python, tuples are additionally collections, just like Python lists, however they’re immutable. Due to this fact, you can’t change them, and attempting to take action will end in errors.

The next code snippet is initialized shopping_list as a tuple.

shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
sort(shopping_list)
# Tuple

In the event you attempt to change the primary merchandise within the tuple you’ll get an error as a result of a Python tuple is an immutable assortment.

shopping_list[0] = 'greens'

# Output
---------------------------------------------------------------------------
TypeError                                 Traceback (most up-to-date name final)
<ipython-input-2-ffdafa961600> in <module>()
----> 1 shopping_list[0] = 'greens'

TypeError: 'tuple' object doesn't help merchandise project

▶ Now run the next code snippet to confirm that the enumerate() perform works as anticipated with tuples.

shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
for index, merchandise in enumerate(shopping_list):
    print(f"index:{index}, merchandise:{merchandise}")

use the enumerate() perform with Python strings

You can too use the Python enumerate() perform to iterate by strings whereas accessing the characters and indices on the similar time.

Here is an instance.

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

From the above output, we see that the characters are printed together with their indices (0-8).

Conclusion👩🏽‍💻

Here is a abstract of what you have realized.

  • You should use for loops to entry the objects and preserve a separate counter or index variable.
  • If you would like, you should use the vary() perform to get the legitimate indexes and entry the objects by indexing within the listing.
  • As a really useful Python manner, you should use Python’s sum up() perform with the syntax: enumerate (iterable). By default, the rely or index begins at 0.
  • You can provide up the behavior get began worth with the syntax enumerate (iterable, begin) to begin the index on the worth get began and associated articles.
  • You should use the enumerate perform when working with tuples, strings, dictionaries, and customarily any Python iterable.

I hope you discovered this tutorial on the enumerate() perform useful. Subsequent, learn to discover the index of an merchandise in Python lists. Maintain coding!

Rate this post
Leave a Comment