while loops, break/continue, sentinels and EOF

The last module's for loop always runs a fixed number of times, known before the loop starts. Some problems instead repeat a step until some condition becomes true, with no fixed count decided in advance. This lesson covers repeating a block with while, and reading input that ends with a special value instead of a count.

Repeating while a condition holds

A while loop checks its condition before every pass, the same way if does, and keeps running the block below it for as long as that condition stays True.

1value = 12limit = 1003while value < limit:4    value *= 25print(value)

128

value starts at 1 and doubles on every pass: 2, 4, 8, and onward. Python checks value < limit again before each pass, and stops the loop as soon as value reaches 128, the first power of two that is no longer less than 100. Unlike a for loop, nothing here says in advance how many passes that will take.

A while loop that never makes its condition False runs forever. Every while loop needs something inside its block that moves the condition closer to False, the way value *= 2 does here. A for loop cannot run forever this way, since range() always hands it a fixed, already-known sequence of values to visit. A while loop carries that risk instead, in exchange for not needing to know the count in advance. It is worth a second look whenever you write one. Check, by hand, that the block genuinely moves the condition toward False on every single pass.

Reading values until a sentinel appears

Some problems mark the end of their input with a special value, called a sentinel, instead of telling you a count in advance.

1total = 02number = int(input())3while number != 0:4    total += number5    number = int(input())6print(total)

4
6
0

10

The program reads one number before the loop starts, then checks whether it is the sentinel 0. As long as it is not, the loop adds it to total and reads the next number, right at the bottom of the block. Reading a number both before the loop and again inside it feels repetitive, but it is what lets the condition see the newest number before deciding whether to keep going.

Choosing a sentinel value only works when the problem's own numbers can never legitimately equal it. A count of players, for example, could safely use 0 as a sentinel, since a real count is always at least 1. That same 0 would be a poor choice for a temperature reading, though, since a real reading might genuinely be zero. Always check what a sentinel rules out before relying on one.

Exiting early with break

break exits a loop the instant Python reaches it, no matter what its condition says. It gives you another way to write a sentinel loop, without reading the same line twice in the code.

1total = 02while True:3    n = int(input())4    if n == 0:5        break6    if n < 0:7        continue8    total += n9print(total)

4
-1
6
0

10

while True: starts a loop whose own condition never turns False on its own, so only the break inside it can end it. Each pass reads one number first, then decides what to do with it: a 0 reaches break and ends the loop right there, before total += n ever runs.

Skipping a pass with continue

continue jumps straight back to the loop's condition, skipping the rest of the current pass. In skip_and_sum.py, a negative number reaches continue before total += n, so it never gets added, while every other pass reaches that line normally.

A loop that runs past the end of input

A while True: loop with no sentinel at all, and no count to stop it, keeps calling input() even after every line has already been read.

1total = 02while True:3    total += int(input())4print(total)

3
5

Traceback (most recent call last):
  File "eof_pitfall.py", line 3, in <module>
    total += int(input())
EOFError

The input only has two lines, 3 and 5. The loop reads both, adds them, and loops back for a third line that does not exist, so input() raises EOFError instead of returning anything. Whenever a loop reads input with no sentinel and no count, check that something inside it actually stops the loop before the input runs out.

Reading every remaining line safely

Python's standard library has a module named sys, brought in with import, that includes sys.stdin: every line still left to read, handed over one at a time. Unlike input(), each line from sys.stdin still has its newline attached, so a line read this way often needs .strip() before you convert or compare it.

1import sys2
3total = 04for line in sys.stdin:5    total += int(line)6print(total)

3
5
7

15

for line in sys.stdin: visits each remaining line in turn, stopping cleanly when there are none left, with no EOFError and no sentinel to watch for. This lesson only needs this one idiom for reading to the end of input; the module on imports tours what else import can bring into a program.

Tracing break and continue in one loop

(nothing printed yet)

Both presets read numbers one at a time until a 0 ends the loop. The preset with a -1 in it still reaches the same total as the one without, since continue skips that single pass without changing total at all.

Recap

This lesson covered repeating a block with while for as long as a condition holds, and reading input that ends with a sentinel value instead of a count. It also covered exiting a loop early with break, and skipping a single pass with continue. Last, it covered the EOFError an unstoppable input loop eventually raises, and reading every remaining line safely with import sys. The three problems below all process values one at a time until something tells the loop to stop.