How to loop with an index in Python

1enumerate()Recommended

enumerate() yields (index, item) pairs, and the loop target unpacks them into two names. The index starts at 0, matching normal list positions.

languages = ["Python", "Go", "Rust"]

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

Output: 0 Python, 1 Go, 2 Rust. Nothing is indexed back into the list, so the loop can't drift out of sync with it — and it works on any iterable, not just sequences.

2Start counting at 1

enumerate() takes a second argument, start, which sets the first value of the counter. Use start=1 for anything a human reads — numbered lists, report rows, line numbers — instead of writing index + 1 everywhere.

tasks = ["Write tests", "Fix the bug", "Ship it"]

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

Prints 1. Write tests through 3. Ship it. start only shifts the counter — it does not skip items, so the whole iterable is still visited.

3range(len(items)) — the C-style habit

This is the loop people carry over from C or Java. It works on a list, but it's strictly worse: you pay an extra items[i] lookup on every line that needs the value, the bounds are yours to get right (len(items) - 1 and + 1 are the classic off-by-one bugs), and it only works on things with a length. Generators, files, zip() objects and map() objects have no len() at all.

languages = ["Python", "Go", "Rust"]

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

# enumerate() works here; range(len(...)) cannot -- a generator has no len()
squares = (n * n for n in range(4))
for i, square in enumerate(squares):
    print(i, square)

The first loop prints the same three lines as enumerate() did; the second prints 0 0, 1 1, 2 4, 3 9. Swap enumerate for range(len(squares)) and you get TypeError: object of type 'generator' has no len(). Reach for range(len(...)) only when you genuinely need positions without the values — say, mutating items[i] in place.

4Two lists at once with zip()

When the "index" you actually wanted was just a way to line up two lists, use zip() — it walks them in lockstep and yields tuples. Need the position as well? Wrap the zip() in enumerate() and unpack the inner tuple in parentheses.

names = ["Ada", "Alan", "Grace"]
scores = [91, 84, 99]

for name, score in zip(names, scores):
    print(name, score)

for i, (name, score) in enumerate(zip(names, scores), start=1):
    print(i, name, score)

zip() stops at the shortest input and drops the rest silently — with [1, 2, 3] and [1, 2] you get two pairs, no warning. Pass strict=True to raise ValueError: zip() argument 2 is shorter than argument 1 instead.

5Which should you use?

6Common variation: dicts and filtering

A dict iterates over its keys, so pass d.items() to enumerate() and unpack the pair in parentheses to get counter, key and value at once — insertion order is guaranteed, so the numbering is stable. The same trick keeps the original index when you filter: enumerate() first, then the if, so the surviving items still carry the position they had in the source list.

settings = {"host": "localhost", "port": 9090, "debug": True}

for i, (key, value) in enumerate(settings.items(), start=1):
    print(i, key, value)

# Index of the original list, kept while filtering
readings = [12, 7, 30, 4, 22]
high = [(i, value) for i, value in enumerate(readings) if value > 10]
print(high)

The dict loop prints 1 host localhost, 2 port 9090, 3 debug True, and the comprehension prints [(0, 12), (2, 30), (4, 22)] — note the gaps at 1 and 3, which is exactly the point: filtering first would have renumbered them 0, 1, 2 and lost where they came from.