Repeating Until We Decide to Stop

A for loop works especially well when there is already a sequence to process:

for score in scores:
    print(score)

Sometimes that sequence does not exist yet. A program might need to ask for tasks until the user enters an empty line. The program cannot know beforehand whether the user will enter two tasks, five tasks, or none.

This is a natural use for a while loop.

Repeating Without Knowing the Count

The condition in while True is always true, so the loop needs an explicit way to stop. Here, the empty string is a sentinel: a special value that ends input and is not part of the collected data.

When break runs, Python immediately leaves the loop and continues with the first statement after it. Read the structure as:

Ask for a value. If it means “stop,” leave the loop. Otherwise, remember it and repeat.

Keep the Sentinel Out of the Data

The order inside the loop matters. Each iteration should:

1. read the next value;
2. check whether it is the sentinel and break if it is;
3. append it only when it is actual data.

If the append happens before the check, the stopping value becomes part of the list. If the user enters the sentinel immediately, the correctly ordered loop runs once but leaves the list empty.

['red', 'green']

A Text Sentinel with Numeric Data

When the data is numeric but the sentinel is a word, keep the input as text until after the stopping check:

lap_times = []

while True:
    text = input("Lap time (finished to stop): ").strip().lower()

    if text == "finished":
        break

    lap_times.append(float(text))

Calling .strip().lower() lets inputs such as Finished work as the same command. Only text that represents an actual lap time reaches float(...).

During Parts 1 and 2, you may assume that values expected to be numeric are entered in a valid numeric form. Part 3 introduces more systematic validation and exception handling.

10
25
-3
stop

[10, 25, -3]

A Numeric Sentinel

A reserved number can also signal the end of input. When input is guaranteed to be numeric, convert it first and then compare the number with the sentinel:

distances = []

while True:
    distance = float(input("Distance (-1 to stop): "))

    if distance == -1:
        break

    distances.append(distance)

Because the comparison happens after conversion, -1 and -1.0 represent the same numeric sentinel. The reserved value cannot also be used as data, and it must still be checked before appending.

Collect First, Process Afterwards

After the collection loop ends, there is a completed list to process. That suggests two loops with different jobs:

• a while True loop collects an amount of input that is not known in advance;
• a for loop later visits each item in the completed list once.

Before collection, you do not know how many values the user will enter. Once it ends, you can process the completed list without asking for more input.

Summarizing Collected Data

Suppose the earlier loop has finished collecting lap_times. A separate loop can calculate their total:

total_time = 0

for lap_time in lap_times:
    total_time = total_time + lap_time

print(f"Number of laps: {len(lap_times)}")
print(f"Total time: {total_time}")

If the user stopped immediately, lap_times is empty. The for loop then runs zero times, so total_time remains 0. A program should handle this case deliberately unless its task guarantees at least one item.

Sessions: 3
Total pages: 47

What break Skips

break skips the rest of its current loop body as well as all later iterations:

while True:
    action = input("Action: ").strip().lower()

    if action == "exit":
        break

    print(f"Accepted: {action}")

print("Goodbye.")

For the stopping input, the Accepted line does not run. The Goodbye line does run because it is after the loop. Trace statements in execution order: indentation shows whether a statement is inside or after the loop.

In the next questions, trace how statement order affects what happens on the stopping iteration.

Check Your Understanding

1. Why does while True need some reachable way to execute break?
2. Why is the sentinel normally checked before .append(...)?
3. Why must a word sentinel be checked before converting numeric data?
4. Why is a for loop often a good choice after collection finishes?
5. What happens when the user enters the sentinel on the first iteration?