while loops, break, continue and loop else

A while loop runs a block again and again for as long as its condition is true. It is the loop to use when you cannot say in advance how many times the work must happen: until the user types a sensible answer, until a number reaches 1, until a search finds what it is looking for. (To go through the items of a list or a range of numbers, the for loop of the next lesson is simpler.)

How a while loop runs

A while statement looks like an if: the word while, a condition, a colon and an indented block. The difference is what happens at the end of the block. Python goes back to the top and tests the condition again, and it keeps doing so until the test comes out false. The test happens before every pass, so when the condition is false from the start, the body never runs at all.

This program follows the Collatz rule: halve an even number, triple an odd one and add 1, and stop at 1.

# The Collatz rule: halve an even number; triple an odd number and
# add 1. Repeat until you reach 1.

n = 6
steps = 0
print(n, end="")
while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = 3 * n + 1
    steps += 1
    print(" ->", n, end="")
print()
print("Steps:", steps)

n = 27
steps = 0
highest = n
while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = 3 * n + 1
    steps += 1
    if n > highest:
        highest = n
print("27 needs", steps, "steps and climbs as high as", highest)

6 -> 3 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1
Steps: 8
27 needs 111 steps and climbs as high as 9232

Each pass changes n, which is what the condition looks at, and counts one step. That is the rule for every while loop: something in the body must move the loop towards its stopping condition. Starting from 27, the same loop needs 111 steps and climbs to 9,232 before it falls back to 1. Whether every starting number reaches 1 has never been proved: the claim is called the Collatz conjecture, and research papers have so far proved only weaker statements about it. So a loop’s stopping condition is a promise you should be able to explain, not just hope for.

When a loop never stops

A loop whose condition never becomes false runs forever. The usual causes are a body that never changes the variable the condition tests, a change in the wrong direction (n += 1 where n -= 1 was meant), and a condition that steps over its target: with n = 1 and while n != 10:, adding 2 on each pass gives 9 and then 11, so n is never equal to 10. A comparison such as n < 10 stops whether n lands on 10 or jumps past it.

If it happens in a terminal, press Ctrl-C: Python raises KeyboardInterrupt, which ends the program with a traceback that shows the line it was running. In the Run bar of this page, Stop ends a run at once, and a run that goes on for too long is stopped for you.

A common mistake: one step too far

Loops that walk through a list by position are easy to get wrong at the end:

marks = [72, 85, 64]
total = 0
i = 0
while i <= len(marks):
    total += marks[i]
    i += 1
print("Total:", total)

Traceback (most recent call last):
  File "off_by_one.py", line 5, in <module>
    total += marks[i]
             ~~~~~^^^
IndexError: list index out of range

The list has three items, at positions 0, 1 and 2, but i <= len(marks) lets the loop run a fourth time with i equal to 3. Use i < len(marks). The for loop of the next lesson does this counting for you, which is why lists are usually walked with for.

break and continue

Two statements change the course of a loop from inside its body:

• break leaves the loop at once. Python goes on with the first line after the loop.
• continue skips the rest of this pass. In a while loop, Python goes straight back to testing the condition.

Both act on the innermost loop they are in, and both are normally written inside an if, so that they happen only in some passes.

while True with break

When the loop can only decide whether to stop halfway through its body, write while True: and leave with break. Asking for input until it makes sense is the classic case:

# Keep asking until the answer is a whole number from 1 to 120.
while True:
    text = input("Your age: ").strip()
    if not text.isdecimal():
        print("Please type your age in digits.")
        continue
    age = int(text)
    if not 1 <= age <= 120:
        print("An age from 1 to 120, please.")
        continue
    break

print("Thank you. Your age is", age)

twenty
²
0
250
34

Your age: Please type your age in digits.
Your age: Please type your age in digits.
Your age: An age from 1 to 120, please.
Your age: An age from 1 to 120, please.
Your age: Thank you. Your age is 34

The program was given five answers, shown above its output. “twenty”, “²”, “0” and “250” are rejected, each with a message, and continue goes back to input() for the next answer; 34 passes both checks and break ends the loop. The answers do not appear after the prompts because the program read them from standard input, not from a keyboard; answers typed at a keyboard would have shown on the screen as they were typed.

isdecimal() is the right check before int(): it is true only for digits that int() can read, including those of other scripts such as ३४. The similar isdigit() also accepts characters such as ², and int("²") fails with ValueError.

continue in a counting loop

continue skips everything below it in the body, including a counter you update at the bottom. Move the counter up:

# -1 marks a reading that the sensor failed to take
readings = [21, 22, -1, 23, -1, 24]

total = 0
count = 0
i = 0
while i < len(readings):
    value = readings[i]
    i += 1
    if value == -1:
        continue
    total += value
    count += 1

print("Good readings:", count)
print("Average:", total / count)

Good readings: 4
Average: 22.5

Here i += 1 comes before the continue. Had it stayed at the bottom of the body, the first -1 would have sent the loop back to the test with i unchanged, to read the same -1 forever.

The else clause of a loop

A while loop may end with an else: block. It runs when the loop stops because its condition is false, and it does not run when the loop is left with break (or with return or an exception). That makes it a natural fit for searches: the break means “found it”, and the else means “searched everything, found nothing”.

def describe(n):
    divisor = 2
    while divisor * divisor <= n:
        if n % divisor == 0:
            print(n, "=", divisor, "x", n // divisor)
            break
        divisor += 1
    else:
        print(n, "is prime")


describe(91)
describe(97)
describe(2)
describe(1)

91 = 7 x 13
97 is prime
2 is prime
1 is prime

def describe(n):
    if n < 2:
        print(n, "is neither prime nor composite")
        return
    divisor = 2
    while divisor * divisor <= n:
        if n % divisor == 0:
            print(n, "=", divisor, "x", n // divisor)
            break
        divisor += 1
    else:
        print(n, "is prime")


describe(91)
describe(97)
describe(2)
describe(1)

91 = 7 x 13
97 is prime
2 is prime
1 is neither prime nor composite

For 91, the loop finds the divisor 7 and leaves with break, so the else is skipped. For 97, no divisor up to 9 works and the next one, 10, is too big (10 × 10 is more than 97), so the condition becomes false and the else reports a prime. Stopping at divisor * divisor <= n is enough because divisors come in pairs, d and n // d, and the smaller of each pair is never above the square root; a later lesson of this module works that out.

The first try gets 1 wrong. For both 2 and 1, divisor * divisor <= n is false from the start, so the body never runs and the else runs at once. That is right for 2 and wrong for 1, which is not a prime. Remember this edge case: an else runs even when the loop did no passes at all. The fixed version deals with numbers below 2 before the loop, with a guard clause.

Key takeaways

• A while loop tests its condition before every pass; if it is false at the start, the body never runs.
• Something in the body must move the loop towards its stopping condition; prefer < over != for counters, and press Ctrl-C to stop a runaway loop in a terminal.
• break leaves the innermost loop; continue goes back to the test. Update counters before any continue.
• while True: with a break in the middle suits input that must be checked before the loop can decide.
• A loop’s else block runs only when the loop ends without break, also when the body never ran: ideal for searches.