What Is Iteration?

A program that sends a reminder email to 10,000 users does not contain 10,000 copies of the sending code. It contains the code once, inside a loop, and the loop runs it once per user. Each run is one iteration, and the loop as a whole is how the program iterates over its users.

How iteration works, step by step

Every loop follows the same cycle:

1. Check. Test the loop's condition, which is a boolean: is there another item, or is the counter still below the limit?
2. Run. If the answer is true, run the loop body once.
3. Update. Move to the next item or change the counter.
4. Repeat. Go back to step 1. When the check gives false, the program continues with the code after the loop.

Here the body runs five times, and each iteration adds the next number to a running total:

total = 0

for n in range(1, 6):
    total = total + n
    print("iteration", n, "total is now", total)

print("Done:", total)

iteration 1 total is now 1
iteration 2 total is now 3
iteration 3 total is now 6
iteration 4 total is now 10
iteration 5 total is now 15
Done: 15

The variable total lives outside the loop, so it keeps its value from one iteration to the next. That pattern, a variable set before the loop and updated inside it, is called an accumulator, and it appears in almost every loop that computes something.

Counting loops and condition loops

There are two kinds of iteration. Definite iteration runs a known number of times: once per item in a list, or once for each number from 1 to 5. Python's for loop is built for this, often together with range().

Indefinite iteration repeats until something happens, and the number of passes is not known in advance. A while loop fits this case:

balance = 100
years = 0

while balance < 200:
    balance = balance * 1.10
    years = years + 1

print(years, "years, balance", round(balance, 2))

8 years, balance 214.36

Money that grows by 10% a year takes 8 years to double. The program found that out by iterating, not by solving an equation. The for loops and while loops guides cover both in Python.

Iterating over a collection

Most loops walk through a collection: the elements of an array, the characters of a string, the lines of a file. Python's for loop hands you each element directly, and enumerate() adds its position:

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

Behind the scenes, for asks the collection for an iterator with iter(), then calls next() on it once per iteration. You can make the same calls yourself:

colors = ["red", "green", "blue"]

it = iter(colors)
print(next(it))
print(next(it))
print(next(it))
print(next(it, "no more items"))

red
green
blue
no more items

Without the default value, the fourth next() raises StopIteration. That exception is the signal a for loop uses to know the collection is finished.

Other languages spell the same idea differently. C counts with an index, while Java and JavaScript also have a loop that hands you each element:

for (int i = 0; i < 3; i++) {
    printf("%s\n", colors[i]);
}

for (String color : colors) {
    System.out.println(color);
}

for (const color of colors) {
    console.log(color);
}

Iteration vs recursion

Recursion is the other way to repeat work: a function calls itself on a smaller version of the problem until it reaches a case it can answer directly. Anything written with one can be written with the other, but they behave differently:

The memory row matters in practice. Python allows about 1,000 nested calls by default, so a recursive sum of 5,000 numbers fails where a loop has no trouble:

def sum_loop(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)

print(sum_loop(100), sum_recursive(100))
print(sum_loop(5000))

try:
    print(sum_recursive(5000))
except RecursionError:
    print("sum_recursive(5000) failed: RecursionError")

5050 5050
12502500
sum_recursive(5000) failed: RecursionError

The recursion visualization shows the stack of calls growing and shrinking step by step.

Common mistakes

The infinite loop. A while loop whose condition never becomes false runs until you stop the program. The usual cause is forgetting the update step, such as leaving out count = count - 1.

Off by one. range(1, 5) gives 1, 2, 3 and 4, not 5, because the end value is excluded. A loop that runs one time too many or too few still runs without an error and gives a wrong answer, which is a logic error.

Changing a list while looping over it. Removing items from the list you are iterating over makes the loop skip elements:

numbers = [1, 2, 2, 3]

for n in numbers:
    if n == 2:
        numbers.remove(n)

print(numbers)

[1, 2, 3]

One 2 survived, because removing the first 2 shifted the second one into a position the loop had already passed. Build a new list instead: numbers = [n for n in numbers if n != 2].

Where to go next

Loops walk through collections, so what an array is is the natural companion page, and what a boolean is explains the true or false checks that decide when a loop stops. When a loop gives the wrong result without an error message, read what a logic error is. To practice writing loops, start the Python course or try the examples above in the Python playground.