Python enumerate() and zip()

3Python enumerate & zip: explained step by step

A plain for loop hands you the items of a collection, but it doesn't tell you where an item came from, and it can only walk one collection at a time. Two built-in helpers fix that: enumerate() adds the position, and zip() walks several collections in step. (A list is just an ordered collection written in square brackets, like ["Asha", "Ben"]. That is all you need to know about lists here.)

enumerate(): the item and its position

enumerate(items) produces pairs of (index, item): first (0, first item), then (1, second item), and so on.

names = ["Asha", "Ben", "Chen"]
for index, name in enumerate(names):
    print(index, name)

The loop header has two variable names. Each pair coming out of enumerate is unpacked into them by position: the first value goes into index, the second into name. With only one variable, the loop would hold the whole pair instead:

for pair in enumerate(["Asha", "Ben"]):
    print(pair)

Counting from 1 with start

Indexes begin at 0, but people count from 1. Pass start=1 and the numbering begins there. Only the numbers change: you still get every item, and none are skipped.

names = ["Asha", "Ben", "Chen"]
for number, name in enumerate(names, start=1):
    print(f"{number}. {name}")

Why not range(len(items))?

You can get the same result with the older style:

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

It works, but you must build a range, ask for the length, and look every item up by index yourself. That is three chances to slip: range(1, len(names)) silently skips the first item, and names[i + 1] crashes on the last one. enumerate says what you mean ("each item with its position") in one step, and it also works on things you can loop over but cannot index, such as the lines of a file.

zip(): walk through lists in step

Sometimes two lists belong together: names and their scores, products and their prices. zip(names, scores) pairs the first name with the first score, the second with the second, and so on, like the two sides of a zip fastener meeting.

names = ["Asha", "Ben", "Chen"]
scores = [88, 92, 79]
for name, score in zip(names, scores):
    print(name, "scored", score)

You are not limited to two. Give zip three lists and every item is a triple:

names = ["Asha", "Ben", "Chen"]
scores = [88, 92, 79]
grades = ["B", "A", "C"]
for name, score, grade in zip(names, scores, grades):
    print(name, score, grade)

zip stops at the shortest

If the lists have different lengths, zip stops as soon as the shortest one runs out. The leftover items are dropped without any warning.

days = ["Mon", "Tue", "Wed", "Thu"]
sales = [120, 95, 140]
for day, amount in zip(days, sales):
    print(day, amount)
print("Pairs made:", len(list(zip(days, sales))))

Thu has no sales figure, so it simply vanishes. If a length mismatch would mean your data is broken, add strict=True (Python 3.10 and newer). Then a mismatch raises a ValueError instead of quietly losing data:

for day, amount in zip(days, sales, strict=True):
    print(day, amount)
# Mon, Tue and Wed are printed, then Python stops with:
# ValueError: zip() argument 2 is shorter than argument 1

Using both together

To number the pairs that zip produces, wrap it in enumerate. Each item is now (number, (name, score)), so the inner pair gets its own parentheses when you unpack it:

names = ["Asha", "Ben", "Chen"]
scores = [88, 92, 79]
for number, (name, score) in enumerate(zip(names, scores), start=1):
    print(f"{number}. {name} - {score}")

Building a dictionary from two lists

A dictionary stores key-value pairs, and zip(keys, values) produces exactly such pairs, so dict() can swallow it in one go:

keys = ["name", "age", "city"]
values = ["Asha", 21, "Pune"]
profile = dict(zip(keys, values))
print(profile)
print(profile["city"])

Unzipping with zip(*pairs)

The same tool works in reverse. The * spreads a list of pairs into separate arguments, and zip then regroups all the first items together and all the second items together:

pairs = [("Asha", 88), ("Ben", 92), ("Chen", 79)]
names, scores = zip(*pairs)
print(names)
print(scores)

The results are tuples (read-only lists written with parentheses).

They are lazy: one pass only

Neither enumerate() nor zip() builds its pairs up front. They return an iterator, a small object that makes the next pair only when something asks for it. If you write print(enumerate(names)) you will see text like <enumerate object at 0x7f3c...> (the address changes from run to run) instead of the pairs. A for loop asks for one pair at a time, so loops work as usual. To look at all the pairs at once, wrap the iterator in list().

The catch: an iterator can be used once. After a loop, or a list(), has taken all of its pairs, it is empty.

names = ["Asha", "Ben"]
pairs = enumerate(names, start=1)
print(list(pairs))
print(list(pairs))

The second line shows an empty list: the first list(pairs) already used everything up. zip behaves the same way. If you need the pairs again, build a fresh zip(...) or keep them with pairs = list(zip(...)).