How Do You Loop Over Multiple Sequences?

zip is the built-in way to iterate over several sequences in lockstep. It returns an iterator of tuples, and tuple unpacking gives you one variable per sequence.

names = ["ada", "grace", "alan"]
scores = [99, 87, 91]

# zip - the idiomatic form
for name, score in zip(names, scores):
    print(name, score)

# The explicit nested loop
for index in range(len(names)):
    print(names[index], scores[index])

# zip plus enumerate, when you need the index too
for index, (name, score) in enumerate(zip(names, scores)):
    print(index, name, score)

All three print the same three pairs. The zip version is the one to write. The nested loop repeats the indexing on every line, has to assume the two lists are the same length, and gets noisier the more sequences you add. The third version is worth knowing because combining enumerate with zip is the standard way to get an index and a pair of values at the same time.

The important behaviour to know is that zip stops at the shortest sequence. If scores were shorter than names, the extra names would be silently dropped and you would never know. That is often the behaviour you want when pairing two files of equal length, but it is a genuine trap when the lengths are supposed to match and do not.

Two more details. zip is lazy, so it does not build a list of pairs in memory unless you wrap it in list(). And it works with any number of sequences, not just two, so a three-way zip is simply zip(a, b, c).

zip stops at the shortest input, which silently discards the tail of the longer one. itertools.zip_longest continues to the end of the longest and substitutes a fill value for the exhausted sequences.

from itertools import zip_longest

left = [1, 2, 3]
right = ["a", "b"]

for number, letter in zip_longest(left, right, fillvalue="-"):
    print(number, letter)

The output is 1 a, 2 b, then 3 -. The third left-hand value is paired with the fill value because the right-hand sequence ran out.

The fillvalue argument is optional, and the default is None. That default is a trap in numeric code, because adding None to a number raises a TypeError. Passing an explicit fill value that is valid for your data — a zero, an empty string, a placeholder object — keeps the loop body free of special cases.

There is a related helper worth mentioning: itertools.zip_longest can also be used with a key function, and more generally the itertools module provides the building blocks for lazy, memory-efficient iteration. groupby groups consecutive items by a key, islice lets you take a slice of an iterator without materialising it, and chain concatenates iterables lazily. When a loop over several sequences becomes awkward, the answer is usually in that module rather than in nested index arithmetic.

The trade-off to state in an interview: zip is the fast, readable default for equal-length inputs, and zip_longest is the safe choice when the lengths might differ and losing data would be a bug.

Use zip, and unpack the pairs into names — for name, score in zip(names, scores): — it is short, it is lazy, and it reads the way the intent does.

Three things to know about it make the difference between using zip well and using it badly.

First, zip truncates at the shortest sequence. If the lengths differ, the extra elements are dropped without warning. When that would hide a bug, either check the lengths first with len(a) == len(b), or use itertools.zip_longest, which pads the shorter sequence instead.

Second, zip returns an iterator, not a list. If you need to iterate over the pairs more than once, or to index into them, or to know their length, convert it with list(). In a single for loop you do not need to.

Third, zip accepts any number of iterables, so three-way and four-way pairing is the same call.

Two alternatives to mention. If you need the index as well, wrap zip in enumerate, which gives you index and tuple. And if the sequences are dicts, the idiomatic pairing is dict.items(), which is more explicit than zipping keys and values separately and avoids a second lookup.

The classic anti-pattern to avoid is the manual index loop with range(len(a)), because it duplicates the indexing and silently misbehaves if the two sequences are different lengths.