Controlling Loops: break and continue

While for and while loops provide powerful ways to repeat blocks of code, sometimes you need more granular control over their execution. You might want to exit a loop entirely before it has run its course, or perhaps skip the rest of the current iteration and move directly to the next one. Python provides two statements for these exact situations: break and continue.

Exiting Early: The break Statement

The break statement terminates the current loop prematurely. As soon as Python encounters a break inside a for or while loop, it immediately exits that loop, and program execution resumes at the very next statement after the loop block.

This is particularly useful when you're searching for something and want to stop as soon as you find it, or if an error condition occurs that makes further iteration pointless.

Consider searching for the first occurrence of a specific number in a list:

numbers = [1, 5, 12, 8, 9, 21, 5, 3]
target = 9
found_at_index = -1 # Initialize with a value indicating not found

print(f"Searching for {target} in {numbers}...")

for index, num in enumerate(numbers):
    print(f"Checking index {index}: value {num}")
    if num == target:
        found_at_index = index
        print(f"Found {target}!")
        break # Exit the loop immediately

# Code here runs after the loop finishes or breaks
if found_at_index != -1:
    print(f"Target {target} first found at index {found_at_index}.")
else:
    print(f"Target {target} not found in the list.")

print("Search complete.")

Output:

Searching for 9 in [1, 5, 12, 8, 9, 21, 5, 3]...
Checking index 0: value 1
Checking index 1: value 5
Checking index 2: value 12
Checking index 3: value 8
Checking index 4: value 9
Found 9!
Target 9 first found at index 4.
Search complete.

Notice how the loop stopped at index 4. The values 21, 5, and 3 were never checked because the break statement caused an immediate exit once num == target became true.

Here's a view of how break alters the flow:

Control flow when a break statement is encountered within a loop. Execution jumps directly to the code following the loop.

Skipping an Iteration: The continue Statement

The continue statement is different from break. Instead of terminating the entire loop, continue skips the rest of the code inside the current iteration and immediately proceeds to the next iteration of the loop.

For a while loop, this means jumping back to check the loop's condition again. For a for loop, it means moving on to the next item in the sequence.

This is useful when you encounter data or a condition within an iteration that you want to ignore or handle differently, without stopping the processing of subsequent items.

Imagine you want to sum only the positive numbers in a list, ignoring any negative numbers or zeros:

data = [10, -5, 20, 0, -15, 30, 5]
positive_sum = 0

print(f"Processing data: {data}")

for num in data:
    print(f"Current number: {num}")
    if num <= 0:
        print("  Skipping non-positive number.")
        continue # Skip the rest of this iteration
    # This code only runs if continue was NOT executed
    print(f"  Adding {num} to sum.")
    positive_sum += num

print(f"\nSum of positive numbers: {positive_sum}")

Output:

Processing data: [10, -5, 20, 0, -15, 30, 5]
Current number: 10
  Adding 10 to sum.
Current number: -5
  Skipping non-positive number.
Current number: 20
  Adding 20 to sum.
Current number: 0
  Skipping non-positive number.
Current number: -15
  Skipping non-positive number.
Current number: 30
  Adding 30 to sum.
Current number: 5
  Adding 5 to sum.

Sum of positive numbers: 65

Here, whenever num <= 0 was true, the continue statement was executed. This prevented the positive_sum += num line from running for -5, 0, and -15, but the loop continued processing the remaining items (30 and 5).

Here's how continue affects the loop's flow:

Control flow when a continue statement is encountered. Execution jumps back to the start of the next loop iteration (or condition check), skipping the rest of the current iteration's code.

break vs. continue

• break: Exits the loop entirely. Execution resumes after the loop.
• continue: Skips the current iteration. Execution resumes at the start of the next iteration (or the loop condition check).

Nested Loops

It's important to remember that break and continue only affect the innermost loop they reside in. If you have nested loops (a loop inside another loop), a break or continue in the inner loop will not affect the outer loop.

for i in range(1, 4): # Outer loop
    print(f"Outer loop iteration {i}:")
    for j in ['a', 'b', 'c', 'STOP', 'd']: # Inner loop
        if j == 'STOP':
            print("  Inner loop breaking!")
            break # Breaks only the inner loop
        if j == 'b':
            print(f"  Skipping '{j}' in inner loop...")
            continue # Continues to next item in inner loop
        print(f"  Processing inner item: {j}")
    # This line is reached after the inner loop completes or breaks
    print(f"Outer loop iteration {i} finished.")
print("All loops complete.")

Output:

Outer loop iteration 1:
  Processing inner item: a
  Skipping 'b' in inner loop...
  Processing inner item: c
  Inner loop breaking!
Outer loop iteration 1 finished.
Outer loop iteration 2:
  Processing inner item: a
  Skipping 'b' in inner loop...
  Processing inner item: c
  Inner loop breaking!
Outer loop iteration 2 finished.
Outer loop iteration 3:
  Processing inner item: a
  Skipping 'b' in inner loop...
  Processing inner item: c
  Inner loop breaking!
Outer loop iteration 3 finished.
All loops complete.

Notice how the break only stopped the processing of ['a', 'b', 'c', 'STOP', 'd'] and the outer loop continued its iterations. Similarly, continue only skipped printing b within each inner loop run.

Mastering break and continue gives you precise control over how your loops execute, allowing you to handle specific conditions efficiently and make your code more responsive to the data it processes. While powerful, use them judiciously; sometimes restructuring the loop condition or using if statements can lead to clearer code than relying heavily on break and continue.