Doing Something More Than Once

Many languages loop by counting: start at 0, stop before the length, index in each time. Python's for hands you the items directly.

$ >>> for fruit in ["apple", "banana", "cherry"]:$ ...     print(fruit)$ apple$ banana$ cherry

fruit is not an index — it is each item, in turn. That is the idiom: if you catch yourself writing for i in range(len(fruits)): and then immediately indexing fruits[i], you have written the position-counting version of a loop that Python already gives you directly.

If you need the position too, enumerate() hands you both without you tracking a counter yourself.

$ >>> for i, fruit in enumerate(["apple", "banana", "cherry"]):$ ...     print(i, fruit)$ 0 apple$ 1 banana$ 2 cherry

range(5) looks like it should produce a list of five numbers, and printing the result of looping over it certainly behaves that way. It is not one — it is a lazy sequence that produces each number only as the loop asks for it.

$ >>> range(5)$ range(0, 5)$ >>> list(range(5))$ [0, 1, 2, 3, 4]$ >>> list(range(2, 10, 3))$ [2, 5, 8]

range(5) counts from 0 up to, but never including, 5 — five numbers, not six. range(2, 10, 3) adds a start and a step: begin at 2, add 3 each time, stop before 10. The stop value is never itself produced, which is the same off-by-one convention string slicing uses.

Looping over two lists in step usually starts as indexing both of them by the same counter. zip() pairs them up directly, one item from each per iteration.

names = ["Ada", "Grace", "Alan"]scores = [98, 91, 87] for name, score in zip(names, scores):    print(f"{name}: {score}")

Try itAdd a fourth name with no matching score, and run it again.

If the two collections are different lengths, zip() stops as soon as the shorter one runs out, silently. A fourth name with no matching score never produces a pairing and never raises an error. Check this explicitly if mismatched lengths would actually be a bug in your program rather than expected.

Use for when you already have the collection to iterate over. Use while when you are repeating until a condition changes, and you do not know in advance how many times that will take.

$ >>> total = 0$ >>> while total < 10:$ ...     total += 3$ >>> total$ 12

Two keywords change a loop's path through its own body without changing the condition that controls it. break exits the loop immediately, skipping every remaining iteration. continue skips only the rest of the current iteration and moves on to the next one.

1. 1

   break stops the loop outright

   Found what you were looking for? Stop checking the rest — nothing after break in that iteration runs, and no further iterations happen either.

2. 2

   continue skips to the next iteration

   Want to ignore this one item and move on? continue jumps straight back to the top of the loop for the next value, without exiting.

3. 3

   else runs only if the loop was never broken

   A for or while loop can carry its own else block, which runs when the loop finishes normally — and is skipped entirely if break ever fired.

for n in [2, 4, 6, 9, 10]:    if n % 2 != 0:        print(f"found an odd one: {n}")        breakelse:    print("every number was even")

Try itChange the 9 to an 8 and run it again.

Change the list to all-even numbers and the loop finishes without ever hitting break, so the else block runs and prints "every number was even". This is the one place else does not mean "otherwise" the way it does on an if — here it means "the loop completed without a break", which is precisely the condition you would otherwise track with a separate flag variable.

total = 0for n in [1, 2, 3, 4, 5, 6]:    if n == 5:        break    if n % 2 == 0:        continue    total += nprint(total)

Unlike some languages, Python does not create a fresh scope for a loop body. The variable you loop with is an ordinary name in the surrounding function or module, and it keeps whatever value it last held once the loop finishes.

$ >>> for fruit in ["apple", "banana", "cherry"]:$ ...     pass$ >>> fruit$ 'cherry'

$ >>> numbers = [2, 4, 6, 7, 8]$ >>> for n in numbers:$ ...     if n % 2 == 0:$ ...         numbers.remove(n)$ >>> numbers$ [4, 7]

4 survives, and it is even — it never gets checked. Removing 2 shifts 4 down into the slot the loop has already passed, so the loop's cursor jumps straight over it to 6. Loop over numbers[:], a copy, or build a new list with a comprehension instead, and the loop you are iterating never changes shape underneath you.