How to Access the Index in a Python for Loop

By the end of this page, you will understand how to get both the position and the value while looping through a list in Python. You will learn the recommended enumerate() approach, how it works, when to start counting from 0 or 1, and what mistakes to avoid.

In Python, a basic for loop gives you each item from a sequence one at a time:

for x in xs:
    print(x)

This is great when you only care about the values. But sometimes you also need the index—the position of each item in the list.

A common beginner instinct is to try to use an index variable directly inside the loop, but Python does not create that variable automatically. You need to ask for it explicitly.

The standard Python way to get both the index and the value is enumerate():

for index, x in enumerate(xs):
    print(index, x)

enumerate() wraps an iterable and produces pairs like:

(0, 8)
(1, 23)
(2, 45)

This matters because:

• it is clear and readable
• it avoids manual counter variables
• it works with many iterable objects, not just lists
• it follows common Python style

If you want counting to begin at 1 instead of 0, use the start argument:

for index, x in enumerate(xs, start=1):
    print(index, x)

That matches your desired output exactly.

Think of a list like a row of numbered lockers:

• the value is what is inside each locker
• the index is the locker number

A normal for loop hands you only the contents:

• 8
• 23
• 45

But enumerate() hands you both the locker number and the contents at the same time:

• locker 0 contains 8
• locker 1 contains 23
• locker 2 contains 45

If you ask enumerate(..., start=1), it simply starts numbering the lockers from 1 for display purposes.

Basic syntax

for index, value in enumerate(sequence):
    print(index, value)

Start counting from 1

for index, value in enumerate(sequence, start=1):
    print(index, value)

Example matching your output

xs = [8, 23, 45]

for index, x in enumerate(xs, start=1):
    print("item #{} = {}".format(index, x))

Output:

item #1 = 8
item #2 = 23
item #3 = 45

Using f-strings instead of .format()

In modern Python, many developers prefer f-strings because they are shorter and easier to read.

xs = [8, 23, 45]

for index, x in enumerate(xs, start=1):
    print(f"item #{index} = {x}")

Example with default indexing

xs = [8, 23, 45]

for index, x in enumerate(xs):
    print(index, x)

Output:

0 8
1 23
2 45

Python uses zero-based indexing by default, which means the first item is at index 0.

Consider this code:

xs = [8, 23, 45]

for index, x in enumerate(xs, start=1):
    print(f"item #{index} = {x}")

Here is what happens step by step:

1. xs is created as a list containing three values:

   • 8
   • 23
   • 45

2. enumerate(xs, start=1) prepares pairs of (index, value):

   • (1, 8)
   • (2, 23)
   • (3, 45)

3. First loop iteration:

   • index = 1
   • x = 8
   • printed output: item #1 = 8

4. Second loop iteration:

   • index = 2
   • x = 23
   • printed output: item #2 = 23

5. Third loop iteration:

   • index = 3
   • x = 45
   • printed output: item #3 = 45

6. The loop ends because there are no more items.

This is much cleaner than manually updating a counter variable.

Getting the index during iteration is common in real programs.

Display numbered lists

tasks = ["Email client", "Fix bug", "Deploy app"]

for i, task in enumerate(tasks, start=1):
    print(f"{i}. {task}")

Show row numbers in data processing

rows = ["Alice", "Bob", "Charlie"]

for row_num, name in enumerate(rows, start=1):
    print(f"Row {row_num}: {name}")

Report errors with positions

values = [10, -2, 30]

for i, value in enumerate(values):
    if value < 0:
        print(f"Invalid value at index {i}: {value}")

Build menu systems

options = ["Start", "Settings", "Quit"]

for i, option in enumerate(options, start=1):
    print(f"{i}) {option}")

Track items in API or file results

Developers often number results when printing logs, validating records, or generating reports.

In real codebases, developers often use enumerate() when they need both the item and its position without managing a separate counter.

Common patterns

Validation with position info

emails = ["a@example.com", "", "c@example.com"]

for i, email in enumerate(emails, start=1):
    if not email:
        print(f"Email missing at row {i}")

Logging progress

files = ["a.txt", "b.txt", "c.txt"]

for i, filename in enumerate(files, start=1):
    print(f"Processing file {i}: {filename}")

Guard clauses inside loops

values = [5, None, 9]

for i, value in enumerate(values):
    if value is None:
        print(f"Skipping missing value at index {i}")
        continue
    print(value * 2)

Pairing index with transformed data

names = ["alice", "bob", "charlie"]

for i, name in enumerate(names, start=1):
    print(f"User {i}: {name.title()}")

enumerate() is preferred over manual counters because it reduces bugs and keeps loops easy to read.

Mistake 1: Assuming index exists automatically

Broken code:

xs = [8, 23, 45]

for x in xs:
    print(index, x)

Why it fails:

• index was never defined
• a plain for loop only gives you the value

Fix:

for index, x in enumerate(xs):
    print(index, x)

Mistake 2: Using range(len(xs)) when enumerate() is clearer

This works:

for i in range(len(xs)):
    print(i, xs[i])

But this is usually better:

for i, x in enumerate(xs):
    print(i, x)

Why avoid range(len(xs)) for simple cases?

• less readable
• more verbose
• easier to make indexing mistakes

Mistake 3: Forgetting that Python starts indexing at 0

xs = [8, 23, 45]

for i, x in enumerate(xs):
    print(f"item #{i} = {x}")

Output:

item #0 = 8
item #1 = 23
item #2 = 45

If you want human-friendly numbering, use:

for i, x in enumerate(xs, start=1):
    print(f"item #{i} = {x}")

Mistake 4: Shadowing names carelessly

list = [8, 23, 45]
for index, value in enumerate(list):
    print(index, value)

This works, but naming a variable list hides Python's built-in list type. Prefer better names like xs, items, or numbers.

Mistake 5: Calling .index() inside the loop

Broken idea:

xs = [8, 23, 45]

for x in xs:
    print(xs.index(x), x)

Why this is risky:

• .index(x) finds the first matching value
• if values repeat, the index may be wrong

Example:

xs = [8, 23, 8]

for x in xs:
    print(xs.index(x), x)

Output:

0 8
1 23
0 8

The last 8 should be at index 2, not 0.

Use enumerate() instead.

Ways to get the index in Python

enumerate() vs range(len(xs))

xs = [8, 23, 45]

for i in range(len(xs)):
    print(i, xs[i])

versus

for i, x in enumerate(xs):
    print(i, x)

Choose enumerate() when:

• you need both item and index
• you are looping directly over a sequence
• readability matters

Choose range(len(xs)) when:

• you specifically need numeric positions for multiple sequences or index-based updates

Zero-based vs one-based counting

# Get index and value
for i, x in enumerate(xs):
    ...

# Start counting from 1
for i, x in enumerate(xs, start=1):
    ...

Key rules

• A plain for x in xs: loop gives only the value
• enumerate(xs) gives (index, value) pairs
• Python indexes usually start at 0
• Use start=1 for display numbering

Recommended pattern

xs = [8, 23, 45]
for i, x in enumerate(xs, start=1):
    print(f"item #{i} = {x}")

Avoid when possible

for i in range(len(xs)):
    print(i, xs[i])

Use this only when you really need index-based access.

Do not do this for loop indexes

for x in xs:
    print(xs.index(x))

This can give wrong results when values repeat.

How do I get the index in a Python for loop?

Use enumerate():

for i, value in enumerate(xs):
    print(i, value)

How do I start the index from 1 instead of 0?

Pass start=1 to enumerate():

for i, value in enumerate(xs, start=1):
    print(i, value)

Is enumerate() better than range(len(list))?

Yes, in most cases. It is shorter, clearer, and less error-prone when you need both the index and the value.

Why is my index variable undefined?

Because Python does not create index automatically in a normal for loop. You must use enumerate() or define your own counter.

Can I use enumerate() with tuples, strings, or other iterables?

Yes. enumerate() works with many iterable objects, including lists, tuples, strings, and file lines.

What happens if the list has duplicate values?

enumerate() still gives the correct position for each item. This is one reason it is better than calling .index() inside the loop.

• for loops — The basic looping structure that enumerate() is used with.
• lists — A common sequence type you iterate over in Python.
• iterables — enumerate() works on any iterable, not just lists.
• range() — Another way to work with numeric positions in loops.
• zero-based indexing — Explains why Python indexes start at 0.
• f-strings — A clean way to format output while printing index and value.
• tuple unpacking — for index, value in ... works because Python unpacks pairs into two variables.