While processing a list, tuple, string, or another iterable, programmers often need both the current item and its position. One approach is to create and update a counter manually.

Python provides the built-in enumerate() function for this purpose. It produces pairs containing a counter and the corresponding item from the iterable.

Prerequisites

What is enumerate()?

enumerate() is a built-in Python function that accepts an iterable and returns an enumerate object.

During iteration, the enumerate object supplies pairs containing the current count and the corresponding value from the original iterable.

Syntax

enumerate(iterable, start=0)

Basic enumerate() Example

Use enumerate() to display the position and value of each programming language:

languages = [
    "Python",
    "Java",
    "C#",
    "JavaScript"
]

for index, language in enumerate(languages):
    print(index, language)

Output:

0 Python
1 Java
2 C#
3 JavaScript

On every iteration, Python unpacks the generated pair into index and language.

What Does enumerate() Return?

Calling enumerate() creates an enumerate object.

languages = ["Python", "Java", "C#"]

result = enumerate(languages)

print(result)
print(type(result))

Possible output:

<enumerate object at 0x...>
<class 'enumerate'>

Convert enumerate() to a List

Convert an enumerate object to a list to view all generated index-value pairs:

languages = [
    "Python",
    "Java",
    "C#"
]

result = list(enumerate(languages))

print(result)

Output:

[(0, 'Python'), (1, 'Java'), (2, 'C#')]

Each element in the resulting list is a tuple containing the counter and the original value.

Set a Custom Starting Number

The optional start parameter changes the first counter value.

languages = [
    "Python",
    "Java",
    "C#"
]

for position, language in enumerate(
    languages,
    start=1
):
    print(position, language)

Output:

1 Python
2 Java
3 C#

Manual Counter vs enumerate()

Using a Manual Counter

languages = [
    "Python",
    "Java",
    "C#"
]

position = 1

for language in languages:
    print(position, language)
    position += 1

Using enumerate()

languages = [
    "Python",
    "Java",
    "C#"
]

for position, language in enumerate(
    languages,
    start=1
):
    print(position, language)

Retrieve Pairs with next()

An enumerate object is an iterator. The built-in next() function retrieves its next pair.

languages = [
    "Python",
    "Java",
    "C#"
]

language_iterator = enumerate(
    languages,
    start=1
)

print(next(language_iterator))
print(next(language_iterator))
print(next(language_iterator))

Output:

(1, 'Python')
(2, 'Java')
(3, 'C#')

enumerate() Object Exhaustion

An enumerate object is consumed as its pairs are requested. After all pairs are produced, the same object is exhausted.

languages = ["Python", "Java"]

numbered_languages = enumerate(
    languages,
    start=1
)

print(list(numbered_languages))
print(list(numbered_languages))

Output:

[(1, 'Python'), (2, 'Java')]
[]

Use enumerate() with a List

products = [
    "Laptop",
    "Keyboard",
    "Mouse",
    "Monitor"
]

for serial_number, product in enumerate(
    products,
    start=1
):
    print(
        f"{serial_number}. {product}"
    )

Output:

1. Laptop
2. Keyboard
3. Mouse
4. Monitor

Use enumerate() with a Tuple

departments = (
    "Finance",
    "Human Resources",
    "Information Technology"
)

for index, department in enumerate(departments):
    print(index, department)

Output:

0 Finance
1 Human Resources
2 Information Technology

Use enumerate() with a String

A string is iterable, so enumerate() can provide the position of each character.

language = "Python"

for index, character in enumerate(language):
    print(index, character)

Output:

0 P
1 y
2 t
3 h
4 o
5 n

Find All Matching Positions

Locate every position where a character appears:

text = "programming"

positions = [
    index
    for index, character in enumerate(text)
    if character == "m"
]

print(positions)

Output:

[6, 7]

Unlike str.index(), this pattern can collect all matching positions rather than only one match.

Use enumerate() with a Dictionary

Iterating directly over a dictionary produces its keys:

employee = {
    "name": "Amina",
    "department": "IT",
    "active": True
}

for index, key in enumerate(
    employee,
    start=1
):
    print(index, key)

Output:

1 name
2 department
3 active

Enumerate Dictionary Items

Use dictionary.items() when both the dictionary key and value are required.

employee = {
    "name": "Amina",
    "department": "IT",
    "active": True
}

for position, item in enumerate(
    employee.items(),
    start=1
):
    key, value = item

    print(
        position,
        key,
        value
    )

Output:

1 name Amina
2 department IT
3 active True

Nested unpacking can make the loop more concise:

for position, (key, value) in enumerate(
    employee.items(),
    start=1
):
    print(position, key, value)

Use enumerate() with a Set

A set is iterable, so it can be used with enumerate(). However, sets do not represent a positional sequence.

skills = {
    "Python",
    "SQL",
    "Git"
}

for count, skill in enumerate(
    skills,
    start=1
):
    print(count, skill)

Use enumerate() with a Generator

squares = (
    number ** 2
    for number in range(1, 6)
)

for position, square in enumerate(
    squares,
    start=1
):
    print(position, square)

Output:

1 1
2 4
3 9
4 16
5 25

Filter by Position

Use the generated index inside a condition. The following example processes values at even-numbered indexes:

values = [
    "A",
    "B",
    "C",
    "D",
    "E",
    "F"
]

for index, value in enumerate(values):
    if index % 2 == 0:
        print(index, value)

Output:

0 A
2 C
4 E

Filter by Item Value

scores = [
    72,
    35,
    91,
    28,
    64
]

for position, score in enumerate(
    scores,
    start=1
):
    if score >= 40:
        print(
            f"Student {position}: Passed"
        )

Output:

Student 1: Passed
Student 3: Passed
Student 5: Passed

Update List Values by Index

The index provided by enumerate() can be used to update values in a mutable sequence.

prices = [
    100,
    250,
    500
]

for index, price in enumerate(prices):
    prices[index] = round(
        price * 1.10,
        2
    )

print(prices)

Output:

[110.0, 275.0, 550.0]

Find the Position of a Matching Item

products = [
    "Laptop",
    "Keyboard",
    "Mouse",
    "Monitor"
]

target_product = "Mouse"
found_position = None

for position, product in enumerate(
    products,
    start=1
):
    if product == target_product:
        found_position = position
        break

print(found_position)

Output:

3

Create a Numbered Menu

menu_options = [
    "Create Record",
    "Update Record",
    "View Record",
    "Exit"
]

print("Application Menu")

for option_number, option in enumerate(
    menu_options,
    start=1
):
    print(
        f"{option_number}. {option}"
    )

Output:

Application Menu
1. Create Record
2. Update Record
3. View Record
4. Exit

Enumerate a Nested List

Use nested enumerate() calls to obtain row and column positions.

matrix = [
    [10, 20, 30],
    [40, 50, 60]
]

for row_index, row in enumerate(matrix):
    for column_index, value in enumerate(row):
        print(
            row_index,
            column_index,
            value
        )

Output:

0 0 10
0 1 20
0 2 30
1 0 40
1 1 50
1 2 60

Number Lines from a File

The start parameter is useful when displaying human-readable line numbers.

with open(
    "notes.txt",
    mode="r",
    encoding="utf-8"
) as notes_file:

    for line_number, line in enumerate(
        notes_file,
        start=1
    ):
        print(
            line_number,
            line.rstrip()
        )

Each file line is processed one at a time and accompanied by its corresponding line number.

Use enumerate() in List Comprehension

Create formatted labels containing serial numbers and values:

departments = [
    "Finance",
    "Sales",
    "Information Technology"
]

numbered_departments = [
    f"{number}. {department}"
    for number, department in enumerate(
        departments,
        start=1
    )
]

print(numbered_departments)

Output:

['1. Finance', '2. Sales', '3. Information Technology']

Combine enumerate() with zip()

zip() combines corresponding values from multiple iterables. enumerate() can add a serial number to every combined record.

names = [
    "Amina",
    "Rahul",
    "David"
]

departments = [
    "IT",
    "Finance",
    "Sales"
]

for employee_number, employee_data in enumerate(
    zip(names, departments),
    start=1
):
    name, department = employee_data

    print(
        employee_number,
        name,
        department
    )

Output:

1 Amina IT
2 Rahul Finance
3 David Sales

Nested unpacking can also be used:

for employee_number, (name, department) in enumerate(
    zip(names, departments),
    start=1
):
    print(
        employee_number,
        name,
        department
    )

Practical Example: Number Customer Orders

orders = [
    {
        "order_number": "ORD-101",
        "amount": 750
    },
    {
        "order_number": "ORD-102",
        "amount": 1500
    },
    {
        "order_number": "ORD-103",
        "amount": 2200
    }
]

for serial_number, order in enumerate(
    orders,
    start=1
):
    print(
        f"{serial_number}. "
        f"{order['order_number']} - "
        f"{order['amount']}"
    )

Output:

1. ORD-101 - 750
2. ORD-102 - 1500
3. ORD-103 - 2200

The start Value Is a Counter

The starting value does not change the underlying iterable or its actual sequence indexes.

colors = [
    "Red",
    "Green",
    "Blue"
]

for count, color in enumerate(
    colors,
    start=100
):
    print(count, color)

Output:

100 Red
101 Green
102 Blue

Common Mistakes

When to Use enumerate()

When enumerate() Is Unnecessary

Best Practices

Hands-On Practice

Knowledge Check

for position, item in enumerate(
    values,
    start=1
):
    print(position, item)

enumerate() Quick Reference

# Basic enumeration
for index, item in enumerate(iterable):
    print(index, item)

# Start counting at one
for position, item in enumerate(
    iterable,
    start=1
):
    print(position, item)

# Convert to a list of tuples
numbered_items = list(
    enumerate(iterable)
)

# Retrieve one pair
iterator = enumerate(iterable)
index, item = next(iterator)

# Enumerate dictionary items
for position, (key, value) in enumerate(
    dictionary.items(),
    start=1
):
    print(position, key, value)

# Enumerate zipped values
for position, (first, second) in enumerate(
    zip(first_values, second_values),
    start=1
):
    print(position, first, second)

# Create numbered labels
labels = [
    f"{position}. {item}"
    for position, item in enumerate(
        iterable,
        start=1
    )
]

# Find matching indexes
indexes = [
    index
    for index, item in enumerate(iterable)
    if item == target
]

Summary