Loop else Blocks

We move the raw_input and if statements to inside the while loop and set the variable running to True before the while loop. First, we check if the variable running is True and then proceed to execute the corresponding while-block . After this block is executed, the condition is again checked which in this case is the running variable. If it is true, we execute the while-block again, else we continue to execute the optional else-block and then continue to the next statement.

Programming

What Is a Loop else Block?

Most programmers know that if statements can have else blocks. But Python extends this idea to loops: both while and for loops can have optional else blocks that execute under specific conditions. A loop else block is code that runs after the loop completes normally—that is, when the loop condition becomes false on its own, without a break statement interrupting it. Think of the else as a way to say: 'If we made it all the way through the loop without breaking out, do this next.'

The critical rule: an else block attached to a loop executes only if the loop terminates naturally (condition becomes false). If you break out of the loop, the else block is skipped entirely.

How Loop else Blocks Execute

When a loop with an else block runs, the program follows a precise sequence. First, the loop condition is checked. If it is true, the loop body executes. After the body finishes, the condition is checked again. This cycle repeats until the condition becomes false. At that moment, instead of simply exiting the loop, the program jumps to the else block (if one exists) and executes it. Only after the else block finishes does execution continue to the next statement after the loop. However, if a break statement is encountered anywhere in the loop body, the loop exits immediately and the else block is completely skipped.

What path does the program take through the loop, and when does the else block actually execute versus when does it get skipped?

State Transitions in a while Loop with else

To see how a loop else block actually behaves, let's trace through a concrete scenario. Imagine a while loop that counts down from 3 to 1, and after the loop finishes naturally, an else block prints a completion message. At each step, the running variable controls whether we re-enter the loop body or transition to the else block.

How does the running variable control whether we re-enter the loop body or jump to the else block?

Worked Example: Searching with a Loop else Block

Finding a Value in a List

Write a program that searches for the number 7 in a list. If found, print the position and break out of the loop. If the loop completes without finding it, the else block should print a message saying the number was not found.

Set up the list and a flag: Create a list of numbers and initialize a variable found to False. This flag will track whether we discovered the target number.

Loop through the list with a condition: Use a while loop that continues as long as we have not found the number. Inside the loop, check each element. If it matches 7, set found to True and break.

Attach an else block: After the while loop, add an else block. This block only runs if the loop completed without hitting the break statement—meaning the number was never found.

Trace the execution: If 7 is in the list, the break statement exits the loop immediately, and the else block is skipped. If 7 is not in the list, the loop condition becomes false after checking all elements, and the else block executes.

The else block provides a clean way to handle the 'not found' case without needing an extra if statement after the loop to check the found flag.

break Versus Natural Loop Termination

The most important distinction with loop else blocks is understanding the difference between breaking out of a loop and letting it terminate naturally. When a break statement is executed inside the loop body, the loop exits immediately, and any else block is completely skipped. In contrast, when the loop condition becomes false on its own (without a break), the else block executes before the program continues to the next statement.

Does the else block run if we break out of the loop versus if the condition naturally becomes false?

Common Mistakes with Loop else Blocks

Expecting the else block to run after a break statement
The else block is explicitly designed to run only when the loop terminates naturally. A break statement bypasses the else block entirely.
Fix: If you need code to run after a break, place it after the entire loop (outside the else block) or use a different control structure.
Confusing loop else with if-else
Loop else blocks are attached to the loop construct, not to conditional statements within the loop. The else block runs after the loop completes, not based on any single if condition.
Fix: Remember: the else block is paired with the while or for keyword, not with any if statement. It runs when the loop condition becomes false.
Assuming the else block runs if the condition is false on the first check
This is actually correct behavior. If the condition is false on the first check, the loop body never executes, but the else block does run. This is a feature, not a bug.
Fix: Recognize that an else block can run even if the loop body never executes. This is useful for handling cases where the initial condition is false.
Using else blocks when a simple if statement would be clearer
Loop else blocks are powerful but can make code harder to read if overused. They are most valuable when the else block represents a genuine 'search completed without finding' or 'loop ran to completion' scenario.
Fix: Use loop else blocks when they genuinely clarify intent. For simple post-loop logic, consider a flag variable and a regular if statement instead.

When to Use Loop else Blocks

Loop else blocks are most useful in search and validation scenarios. If you are looping through a collection looking for a specific value, and you want to take an action only if the search completes without finding it, an else block is ideal. Similarly, if you are validating a condition across multiple items and want to execute code only if all items pass validation, an else block provides a clean, readable way to express that logic. The key is that the else block represents something that should happen only if the loop ran to completion without interruption.

Always be explicit about why you are using a loop else block. Add a comment explaining that the else block runs only if the loop completes naturally, not if a break is encountered. This helps other programmers (and your future self) understand the control flow.

Practice: Predicting else Block Execution

What do you think happens?

A while loop checks if a counter is less than 5. Inside the loop, the counter increments by 1 each iteration. There is no break statement. Will the else block execute?

Yes, because the loop will eventually terminate naturally when the counter reaches 5
No, because the loop will break before the else block can run
Only if the counter starts at 0
Only if the counter starts at a value greater than 5

Reveal answer

Answer: Yes, because the loop will eventually terminate naturally when the counter reaches 5

Since there is no break statement, the loop will run until the condition becomes false (when the counter reaches 5 or higher). At that point, the else block executes. The initial value of the counter does not matter—as long as there is no break, the else block will run.

MEDIUM

Write a for loop that iterates through the numbers 1 to 10. If the number 7 is found, print 'Found 7' and break. Otherwise, after the loop completes, the else block should print 'Number 7 not found'. Predict: will the else block execute? Why or why not?

Hints

Remember that 7 is in the range 1 to 10, so the break will execute.
When break executes, the else block is skipped entirely.
Think about what happens to the else block when the loop exits via break versus when it exits naturally.

Your attempt (not saved)

Summary

A loop else block is optional code that executes only when a loop terminates naturally (its condition becomes false), not when a break statement exits the loop.
If a break statement is encountered, the else block is skipped entirely and execution continues to the next statement after the loop.
Loop else blocks are most useful in search and validation scenarios where you need to take an action only if the loop completes without interruption.
The else block runs even if the loop condition is false on the first check, meaning the loop body never executes—this is intentional and often useful.
Always clarify with comments why you are using a loop else block, as it can be a less familiar construct to other programmers.

Key Takeaways

A loop else block executes only when the loop terminates naturally (condition becomes false), not when a break statement exits the loop.
Loop else blocks are ideal for search and validation scenarios where you need to handle the 'not found' or 'all items passed' case.
If the loop condition is false on the first check, the else block still executes—the loop body is skipped, but the else block runs.
Always use comments to clarify that an else block runs only on natural termination, not after a break.
Common mistake: assuming the else block runs after a break statement; it does not.