break, continue, pass — when and why: Worked examples

The scenario matrix

Think of a loop as a machine that can be interrupted. The situations differ along a few axes: which keyword, where the interrupt sits (start / middle / end of body), is there an else (and for both for and while), is the loop nested, and degenerate cases (empty data, or a condition that is false immediately). Below is every cell we cover.

#	Cell (case class)	Keyword	Twist being tested
A	Search, target present	`break`	stop early, keep the index
B	`for...else`, target absent	`break` + `else`	`else` fires when no break
C	Filter/skip an item	`continue`	rest of body skipped, loop lives on
D	`continue` in a `while` — advance-the-counter trap	`continue`	forgetting `i += 1` = infinite loop
E	Empty `for` (degenerate)	all three	body runs zero times
F	`while` condition false immediately (degenerate)	`while...else`	body zero times, `else` still runs
G	Nested loops — which loop does `break` leave?	`break`	only the innermost exits
H	Nested loops — which loop does `continue` skip?	`continue`	only the innermost iterates
I	Placeholder body	`pass`	syntax needs a statement, logic is empty
J	Real-world word problem	`break`+`continue`	vending machine / stock check
K	Exam twist: `continue` vs `else`	`continue`	does skipping suppress `else`? (No)

We hit every cell A–K below. Each cell gets its own annotated execution strip (a picture of the loop's rounds) so you can see the control flow, not just read it.

Cell A — `break`: search, target present

The strip below is a picture of the loop's rounds. Each column is one iteration (i, x). A cyan box = the body ran and we moved on; the amber octagon with the word "BREAK" = where we bail out. Greyed columns are iterations that never happen because we already left.

Worked example Find the first even number and stop

nums = [7, 3, 9, 4, 6]
for i, x in enumerate(nums):
    if x % 2 == 0:
        first_even_index = i
        break
print(first_even_index)

Forecast: which index prints?

Read enumerate. It pairs each index with its value, in order: index 0 with 7, index 1 with 3, index 2 with 9, index 3 with 4, index 4 with 6. So i and x step together, i counting 0,1,2,3,4 while x walks the list. Why this step? We need the position, not just the value, so enumerate glues each value to its index.
Test x % 2 == 0. The symbol % is modulo — the remainder after division. x % 2 == 0 means "even". At i=0,1,2 the values 7,3,9 give remainder 1 (odd), so we skip. Why this step? break should fire only on the condition we actually care about.
First even is 4 at i=3. We store first_even_index = 3, then break (the amber octagon in the strip). Why this step? Once found, scanning 6 (at i=4) is wasted work — break bails out (cell A's whole point), which is why the last column is greyed "unreached".

Answer: 3.

Verify: nums[3] == 4, and 4 % 2 == 0. ✔ We never touched index 4.

Cell B — `for...else`: target absent

The for...else and while...else else clause is the mirror image of break: it runs only if the loop finished without breaking.

Walk the flowchart below before the example — it is the map for every else case on this page. Read the labels, not the colours (each box is also shaped and lettered so colour-blind readers get the same information):

Start at the top-left rectangle labelled "check condition". If items remain, follow the arrow marked "item" right into the rectangle "run body B" (recall: B = the loop body).
Inside the body two things can happen. A continue (arrow labelled "continue") jumps to the rectangle "next item" and loops back to the condition. A break (the arrow labelled "break") leaves along the path to the octagon "break → exit" and skips the else entirely.
If the condition ever runs out of items with no break, you drop down the arrow labelled "done / no break" to the rectangle "loop ends naturally", and only then does the rounded box "else clause" run.

The single rule the picture encodes: the "else clause" box is reachable only along the path labelled "no break".

Worked example Search that

fails

nums = [7, 3, 9, 5]
for x in nums:
    if x % 2 == 0:
        print("found even:", x)
        break
else:
    print("no even number")

Forecast: does else run?

Scan all four values 7,3,9,5 — all odd, so x % 2 == 0 is never true. Why this step? break is the only thing that can suppress else; if it never fires, else is guaranteed.
Loop ends naturally (iterator exhausted, no break) — the "done / no break" path in the figure. Why this step? "Finished naturally" is the exact trigger condition for else.
else runs, printing no even number. Why this step? We reached the "else clause" box precisely because we travelled the "no break" arrow — confirming the rule and answering the forecast: yes, else runs.

Answer: prints no even number.

Verify: every element is odd → min(x % 2 for x in nums) == 1, so no break, so else fires. ✔

Cell C — `continue`: filter one item

The strip below marks each n from 1 to 8: cyan "add" columns feed total, amber "skip" columns are the ones continue drops.

Worked example Sum everything except multiples of 4

total = 0
for n in range(1, 9):      # 1..8
    if n % 4 == 0:
        continue
    total += n
print(total)

Forecast: sum of 1..8 is 36 — what do we subtract?

List the numbers: 1,2,3,4,5,6,7,8. Why this step? range(1, 9) stops before 9 — a classic off-by-one to check.
continue on n % 4 == 0 removes 4 and 8 (the multiples of 4, the amber columns). Why this step? continue skips total += n for exactly those items — the "skip" logic sits at the top so the addition line stays clean.
Add the survivors: 1+2+3+5+6+7 = 24. Why this step? Only the cyan columns ever reach total += n, so summing just those gives the final answer — every amber column contributed nothing.

Answer: 24.

Verify: full sum 36, minus skipped 4 + 8 = 12, equals 24. ✔

Cell D — `continue` in a `while`: the counter trap

The strip below shows both layouts side by side: the top row (increment before continue) terminates; the bottom row (increment after) freezes on an even i forever — the amber "STUCK" marker.

Worked example Print odd numbers 1..7 with

while + continue

i = 0
while i < 7:
    i += 1                 # advance FIRST — before any continue
    if i % 2 == 0:
        continue           # skip even i
    print(i)

Forecast: which numbers print, and does it ever hang?

Increment first. On entry i=0; the first line makes i=1. Why this step? If i += 1 were after continue, then an even i would skip the increment and re-test the same even i forever (the bottom "STUCK" row of the figure).
continue skips the print for even i (i = 2,4,6). Why this step? We only want odds; skipping keeps print unnested.
Loop stops when i reaches 7 and the next test 7 < 7 is false. Why this step? Because we advanced i on every round (including skipped ones), i is guaranteed to climb to 7 — so termination is certain, answering the "does it hang?" forecast with no.

Answer: prints 1, 3, 5, 7.

Verify: odds in 1..7 are {1,3,5,7}; count = 4. ✔ (Increment-before-continue guarantees termination.)

Cell E — degenerate input: empty `for`, body runs zero times

The strip below shows an execution timeline with no columns at all — a visual reminder that "zero rounds" is a real, legal outcome — with the amber else box firing at the end.

Worked example Loop over nothing

total = 0
for x in []:               # empty list
    total += x
    break                  # never reached
else:
    print("ran else, total =", total)

Forecast: does break fire? does else fire?

Iterate over []. There are no items, so the body — including break — never executes. Why this step? A loop that never runs its body cannot break (cell E's core surprise — a degenerate case).
No break ever happened, so the else clause runs. Why this step? "Completed without break" is trivially true when the body ran zero times — the empty timeline still ends on the "no break" path, so else must fire. That answers both forecasts: break no, else yes.
total stayed 0. Why this step? No total += x ever ran, so the variable keeps its initial value — proving the printed number is 0.

Answer: prints ran else, total = 0.

Verify: empty loop ⇒ total == 0 and else runs (no break). ✔

Cell F — degenerate `while`: condition false immediately

Cell E used a for. The while version of "the body never runs" is a condition that is false the very first time it is checked — and we test what while...else does then.

The strip below shows the very first condition-check failing (amber "False" tag on round 0), the body strip empty, and else still firing.

Worked example

while...else where the condition is false from the start

attempts = 0
while attempts > 0:        # 0 > 0 is False immediately
    print("trying...")
    attempts -= 1
    if attempts == 0:
        break
else:
    print("nothing to do")

Forecast: does anything inside the loop print? does else run?

Check attempts > 0 first. attempts is 0, and 0 > 0 is False, so we never enter the body — no trying..., no break. Why this step? A while checks its condition before each round; a false-at-start condition is the degenerate case for while.
No break ran (the body never ran), so while...else behaves exactly like for...else: else fires on natural completion. Why this step? The else-suppression rule keys only on break, never on how many times the body ran.
else runs, printing nothing to do. Why this step? The only reachable exit here is the "condition false, no break" path, which always leads to else — so the loop body prints nothing and else prints, answering both forecasts.

Answer: prints only nothing to do.

Verify: condition false at start ⇒ body ran 0 times, no break ⇒ else runs. ✔

Cell G — nested loops: which loop does `break` leave?

The grid below is the map of every (r, c) pair: cyan cells run hits += 1, the amber octagon in each row is where the inner loop breaks, and grey cells are unreached because that row already broke.

Worked example

break leaves only the inner loop

hits = 0
for r in range(3):         # outer: r = 0,1,2
    for c in range(3):     # inner: c = 0,1,2
        if c == r:
            break          # leaves ONLY the inner loop
        hits += 1
print(hits)

Forecast: how many times does hits += 1 run?

break targets the nearest enclosing loop — the inner c loop. The outer r loop keeps going. Why this step? A single break cannot exit two loops; this is the #1 nested-loop mistake.
Trace each outer row (see figure — cyan cells run hits += 1, amber octagon is where inner breaks):
- r=0: c=0 → c==r immediately, break. hits += 1 runs 0 times.
- r=1: c=0 (hit, +1), c=1 → break. 1 time.
- r=2: c=0 (+1), c=1 (+1), c=2 → break. 2 times. Why this step? Counting per-row shows the inner loop restarts fresh for every r.
Total: 0 + 1 + 2 = 3. Why this step? Because the outer loop is never broken, every row contributes its own cyan-cell count, and we simply add the three row totals to get the answer.

Answer: 3.

Verify: hits == sum(r for r in range(3)) == 0+1+2 == 3. ✔

Cell H — nested loops: which loop does `continue` skip?

Cell G showed break only leaves the inner loop. continue is the same story: it skips only the rest of the inner iteration, and the inner loop keeps iterating; the outer loop is untouched.

The grid below is the twin of cell G's: same 3×3, but now the diagonal cell in each row is an amber "skip" (that one c is passed over) and every other cell still counts — no row is cut short.

Worked example

continue skips only the inner round

pairs = 0
for r in range(3):         # outer: r = 0,1,2
    for c in range(3):     # inner: c = 0,1,2
        if c == r:
            continue       # skip THIS inner round only
        pairs += 1
print(pairs)

Forecast: how many (r, c) pairs get counted?

continue affects the nearest enclosing loop — the inner c loop. It skips pairs += 1 for that one c, then the inner loop moves to the next c. The outer loop never notices. Why this step? Proves continue, like break, is "innermost only" — the exact partner fact to cell G.
Trace each row — every c runs except c == r (which is skipped):
- r=0: skip c=0; count c=1,2 → 2.
- r=1: skip c=1; count c=0,2 → 2.
- r=2: skip c=2; count c=0,1 → 2. Why this step? Unlike break, continue does not cut the row short — only one cell per row is dropped.
Total: 2 + 2 + 2 = 6. Why this step? Each of the three full rows keeps 2 of its 3 cells, so the grand total is just three rows times two survivors — the visual sum of all the cyan cells.

Answer: 6.

Verify: each of 3 rows has 3 cells, minus 1 skipped per row: 3*(3-1) == 6. ✔

Cell I — `pass`: a legal but empty body

The strip below contrasts the three keywords on the same branch: break exits (amber octagon), continue jumps to next round (amber curved arrow), and pass is a hollow box that changes nothing — execution falls straight through to the next line.

Worked example Placeholder branch and stub function

def route(kind):
    if kind == "admin":
        pass               # TODO: build admin flow later
    else:
        return "guest"
    return "admin-stub"
 
print(route("admin"))
print(route("visitor"))

Forecast: what does each call return?

route("admin"): enters the if, runs pass (does nothing), falls through to the line after the if/else and returns "admin-stub". Why this step? Python's grammar requires at least one statement in any indented block — you cannot leave the body of an if: (or def:, for:, class:) empty, or it is a SyntaxError. pass is that one required statement when you genuinely have nothing to do; it never changes control flow (unlike continue/break, which jump). See Functions and def for the same trick used as an empty function stub.
route("visitor"): the else runs and returns "guest" before reaching the final line. Why this step? Shows pass occupies the branch only to satisfy syntax, without affecting the other branch.

Answer: admin-stub, then guest.

Verify: route("admin") == "admin-stub" and route("visitor") == "guest". ✔

Cell J — real-world word problem

The strip below walks the snack list left to right: amber "skip (too dear)" columns are continued, the first affordable snack is the cyan "BUY" column, and everything after it is greyed "unreached" because we break.

Worked example Vending machine: dispense the first in-stock snack you can afford

snacks = [("chips", 60), ("cookie", 25), ("soda", 40), ("water", 20)]
wallet = 30
chosen = None
for name, price in snacks:
    if price > wallet:
        continue           # can't afford this one — skip it
    chosen = name
    break                  # afford it AND it's first — take it, stop
print(chosen)

Forecast: with 30 rupees, which snack comes out? (Guess before reading — note that water at 20 is cheapest, but is it first?)

chips costs 60 > 30 → continue. The first column of the strip is amber "skip": the if price > wallet test is true, so continue jumps past chosen = name and break straight to the next snack. Why this step? continue is the clean way to say "not this one" without wrapping the buy logic in an else; the loop simply moves on.
cookie costs 25 ≤ 30 → we do NOT continue. Now price > wallet is false, so we fall past the continue, run chosen = "cookie", then hit break. Why this step? This is where break and continue interact: continue filtered out the unaffordable snack, and the moment a snack survives that filter, break locks it in. Together they encode "first item that passes the test".
break stops the scan. The cyan "BUY" column is cookie; soda (40) and water (20) are greyed "unreached". Why this step? We want the first affordable snack in list order, not the cheapest — break guarantees we never look past the winner, which is why the cheaper water is never reached.

Answer: cookie.

Verify: first item with price <= 30 in list order is cookie (25); soda/water never reached. ✔

Cell K — exam twist: does `continue` suppress `else`?

This is the trap that catches most students: they know break cancels the else, and wrongly assume continue does too. It does not. The strip below shows the loop running to natural completion even though a continue fired mid-way — so the amber else box still lights up.

Worked example The trap question —

continue vs else

for n in [1, 3, 5]:
    if n == 3:
        continue           # NOT break
    print("saw", n)
else:
    print("done, no break")

Forecast: does the else print? Most people guess "no". Guess before reading.

n == 1: no continue. 1 == 3 is false, so we skip the continue and run print("saw", n) → prints saw 1. Why this step? Establishes the normal path when the continue condition is false — the body runs fully.
n == 3: continue fires, skipping its print, but the loop keeps iterating to n = 5. Why this step? continue only abandons the current round; it is not break, so it does nothing to the loop's overall completion status — this is the exact fact the exam tests.
n == 5: no continue, so print("saw", n) → prints saw 5. Then the iterator is exhausted. Why this step? Confirms the loop reaches its natural end — the trigger for else.
Loop finished with no break ever ⇒ else runs, printing done, no break. Why this step? The for...else and while...else rule keys only on break. Since only a continue fired (never a break), the "no break" path is taken and else executes — refuting the common "no" guess.

Answer: prints saw 1, saw 5, done, no break.

Verify: two values (1,5) printed and else ran (no break). ✔

The matrix, filled

Recall Which example covered which cell?

A::: Ex A (first even, break) B::: Ex B (all odd, for...else fires) C::: Ex C (skip multiples of 4, continue) D::: Ex D (while + continue, increment-first) E::: Ex E (empty for, body zero times) F::: Ex F (while condition false immediately, while...else) G::: Ex G (nested break, inner only) H::: Ex H (nested continue, inner only) I::: Ex I (pass as stub) J::: Ex J (vending machine, break+continue interact) K::: Ex K (continue does NOT suppress else)

Connections

For Loops — cells A, B, C, E, G, H, K run on for iteration.
While Loops — cells D and F are the while counter trap and the degenerate while.
for...else and while...else — cells B, E, F, K test the else-vs-break rule for both loop kinds.
Conditionals (if-elif-else) — every keyword here lives inside an if.
Functions and def — cell I stubs a function body with pass.
Prime Number Checking — the archetypal while...else + break search (cell B pattern).