# 7.3: The while statement

- Page ID
- 40894

Computers are often used to automate repetitive tasks. Repeating identical or similar tasks without making errors is something that computers do well and people do poorly. In a computer program, repetition is also called **iteration**.

We have already seen two functions, `countdown`

and `print_n`

, that iterate using recursion. Because iteration is so common, Python provides language features to make it easier. One is the for statement we saw in Section 4.2. We’ll get back to that later.

Another is the `while`

statement. Here is a version of `countdown`

that uses a `while`

statement:

def countdown(n): while n > 0: print(n) n = n - 1 print('Blastoff!')

You can almost read the `while`

statement as if it were English. It means, “While `n`

is greater than 0, display the value of `n`

and then decrement `n`

. When you get to 0, display the word `Blastoff!`

”

More formally, here is the flow of execution for a `while`

statement:

- Determine whether the condition is true or false.
- If false, exit the
`while`

statement and continue execution at the next statement. - If the condition is true, run the body and then go back to step 1.

This type of flow is called a loop because the third step loops back around to the top.

The body of the loop should change the value of one or more variables so that the condition becomes false eventually and the loop terminates. Otherwise the loop will repeat forever, which is called an **infinite loop**. An endless source of amusement for computer scientists is the observation that the directions on shampoo, “Lather, rinse, repeat”, are an infinite loop.

In the case of `countdown`

, we can prove that the loop terminates: if `n`

is zero or negative, the loop never runs. Otherwise, `n`

gets smaller each time through the loop, so eventually we have to get to 0.

For some other loops, it is not so easy to tell. For example:

def sequence(n): while n != 1: print(n) if n % 2 == 0: # n is even n = n / 2 else: # n is odd n = n*3 + 1

The condition for this loop is `n != 1`

, so the loop will continue until `n`

is 1, which makes the condition false.

Each time through the loop, the program outputs the value of `n`

and then checks whether it is even or odd. If it is even, `n`

is divided by 2. If it is odd, the value of `n`

is replaced with `n*3 + 1`

. For example, if the argument passed to sequence is 3, the resulting values of `n`

are 3, 10, 5, 16, 8, 4, 2, 1.

Since `n`

sometimes increases and sometimes decreases, there is no obvious proof that `n`

will ever reach 1, or that the program terminates. For some particular values of `n`

, we can prove termination. For example, if the starting value is a power of two, `n`

will be even every time through the loop until it reaches 1. The previous example ends with such a sequence, starting with 16.

The hard question is whether we can prove that this program terminates for *all* positive values of `n`

. So far, no one has been able to prove it *or* disprove it! (See http://en.Wikipedia.org/wiki/Collatz_conjecture.)

As an exercise, rewrite the function `print_n`

from Section 5.8 using iteration instead of recursion.