Loop else

Master the Python else clause in loops to execute code only when a loop finishes naturally without being interrupted by a break.

What it is

In most programming languages, else is associated with conditional statements. In Python, however, else can also be attached directly to for and while loops. This block executes only if the loop completes its iteration sequence normally. If the loop is terminated early via a break statement, the else block is skipped entirely.

The mental model is "search and handle": you are searching for something within an iterable. If you find it, you break out of the loop (and skip the else). If you exhaust the entire iterable without finding what you were looking for, the loop ends naturally, triggering the else block.

Why it matters

• Readability: It eliminates the need for boolean flags (e.g., found = False) to track whether a search was successful.
• Logic Clarity: It explicitly separates the "success" path (inside the loop) from the "failure/not found" path (in the else block).
• Conciseness: Reduces boilerplate code when checking for the absence of items or conditions.
• Error Handling: Useful for validating that all items in a collection meet specific criteria before proceeding.

Syntax or steps

The syntax places the else keyword at the same indentation level as the for or while keyword, followed by a colon. The body of the else block must be indented relative to the else.

for item in iterable:
    if condition_met:
        break
else:
    # Executes only if 'break' was NOT encountered
    action_if_not_found()

Example

Consider a scenario where we check if any number in a list is negative. If we find one, we stop immediately. If we check all numbers and none are negative, we print a confirmation message.

numbers = [10, 5, 8, 3]

for n in numbers:
    if n < 0:
        print(f"Found negative number: {n}")
        break
else:
    print("All numbers are non-negative.")

Explanation:

1. The loop iterates through numbers. Since no number is less than 0, the if condition never triggers, so break is never executed.
2. Because the loop finished iterating through all elements naturally, the else block runs, printing "All numbers are non-negative."
3. If numbers contained -1, the break would trigger, exiting the loop immediately and skipping the else block.

Common mistakes

• Indentation errors: Placing else inside the loop body instead of aligning it with the for/while keyword causes a syntax error or logical bug.
• Confusing with try/except/else: Remember that loop else depends on break, not exceptions. An exception raised inside the loop will propagate up unless caught, bypassing the loop's else logic differently than a break.
• Using continue incorrectly: continue skips the rest of the current iteration but does not exit the loop. Therefore, using continue does not prevent the else block from running if the loop eventually finishes normally.
• Empty iterables: If the iterable is empty, the loop body never runs, but the loop technically "completes" without breaking. Consequently, the else block will execute. Ensure this behavior matches your intent.

When to use it

Compare loop else with the traditional flag-based approach.

Practice

Guided Exercise: Write a loop that checks if the word "python" exists in the list ["java", "c++", "ruby"]. Print "Not found" if it doesn't exist using the else clause.

Challenge: Modify the previous exercise to check if any string in the list has more than 4 characters. If none do, print "No long strings found."

Hint: Use len(item) > 4 as your condition for breaking.

Quick check

Question: Does the else block run if the loop terminates because the iterable was exhausted?

Answer: Yes. The else block runs whenever the loop finishes normally, which includes exhausting the iterable. It only fails to run if a break statement interrupts the flow.

Summary

Python's loop else clause provides a syntactic sugar for handling cases where a loop completes without interruption. By associating the else block with the absence of a break, developers can write cleaner search and validation logic without relying on external state variables.