Debugging Techniques for Control Flow

While loops check their condition before each iteration; a boolean flag controls when the loop exits.

Programming

Close the Gap Between Intention and Execution

When a loop prints unexpected output or appears to run forever, the important question is not only what you intended the loop to do. You must determine what actually happened at each condition check, variable update, iteration, and branch. Loop tracing means following that exact sequence of state changes. Recording variable states step by step is the most reliable way to find where execution diverged from your mental picture.

Debug a loop as a sequence of states, not as one large block of code. At each step, ask what the condition is, what the variables contain, and which statement runs next.

Flag Checks Before Each Iteration

A while loop checks its condition before every iteration. When a boolean variable acts as a flag, the loop continues while that flag is True. The loop body can change the flag to False. That change does not erase the current iteration; it affects the next condition check. After the body finishes, the loop checks the flag again. If the flag is now False, the loop exits instead of starting another iteration.

What happens to the flag and loop execution each time the while condition is checked?

Tracing a Flag-Controlled Loop

Suppose a loop starts with running equal to True and number equal to 1. During each loop body, number is processed. When number reaches 3, the body changes running to False. Trace the condition checks and state changes.

Initial check: running is True, so the while loop begins its first iteration with number equal to 1.

First body execution: The body processes number 1. The flag is not yet changed to False, so the next condition check still permits another iteration.

Second body execution: The body processes number 2. The loop continues to the next condition check.

Third body execution: The body processes number 3 and changes running to False.

Final check: The body has finished, so the while condition is checked again. running is now False, so no fourth iteration begins.

The flag change ends the loop at the next condition check. It does not prevent the body that changed the flag from finishing.

Find the First Divergence

A useful debugging trace records the state before a condition check, the result of that check, the action taken in the loop body, and the state after the body. Compare this actual trace with your expected trace one step at a time. The first mismatch is the most useful location to investigate. Later unexpected behavior may simply be a consequence of that earlier mismatch.

Write down the initial values of the loop variables and boolean flag.
Record the condition before the first iteration.
Record which branch or loop body runs.
Write down every variable update made by that body.
Check the condition again using the updated values.
Compare the actual sequence with the sequence you expected and mark the first difference.

At which condition check, update, iteration, or branch does actual execution first differ from the expected path?

Natural Completion and Early Exit

A for loop iterates over the values in a sequence. Python also allows a for loop to have an else clause. The else block runs when the loop has gone through all of its iterations naturally. If a break statement exits the loop early, the else block is skipped. Therefore, reaching the end of the loop body repeatedly is different from leaving the loop through break.

How does control flow differ when a loop finishes all iterations naturally versus when break stops it early?

When does execution move from the for loop to else, and what changes if break is encountered first?

Predicting the Else Clause

A for loop processes the values generated by range(1, 5). It prints each value, and its else block prints a completion message. Predict the order of events.

Sequence creation: range(1, 5) generates 1, 2, 3, and 4. The upper boundary 5 is not included.

Iteration: The loop processes and prints 1, then 2, then 3, then 4.

Completion decision: All values have been processed and no break has exited the loop.

Else execution: Because the loop completed naturally, control moves to the else block.

The values 1, 2, 3, and 4 are processed first, followed by the else block.

Mistakes That Distort a Trace

Treating a while condition as if it were checked only once
The current body execution continues. The changed flag is used at the next condition check.
Fix: Record the state after the body, then trace the next condition check explicitly.
Assuming the for loop else block always runs
The else block runs only after natural completion, not after break exits early.
Fix: Mark whether the loop exhausted its values or left through break.
Misreading range boundaries
The source example specifies that range(1, 5) generates integers from 1 up to but not including 5.
Fix: Write out the generated values before tracing the loop body.
Skipping variable states between iterations
The first unexpected result may arise earlier, during a condition check or update.
Fix: Record the relevant variables before and after every loop body execution.

Loop ending	What happened	Does for else run?
Natural completion	All loop iterations finished without break	Yes
break termination	break exited the loop before all iterations finished	No
while flag becomes False	The next condition check prevents another iteration	Not applicable to the for else rule

Trace Before You Change

EASY

A while loop begins with running equal to True and count equal to 0. Each iteration increases count by 1. When count becomes 2, the loop body changes running to False. Trace the initial condition check, every body execution, the value of count, and the final condition check. Then decide whether a third iteration begins.

Hints

The condition is checked before the first iteration and again after each body execution.
The body that changes running to False still completes.
Use the updated value of running for the next condition check.

Your attempt (not saved)

MEDIUM

A for loop processes the values from range(1, 5). It contains a break that runs when the current value is 3, followed by an else clause. Predict which values are processed and whether the else clause runs. Explain your answer using the difference between natural completion and break termination.