Control Flow: Conditionals and Loops

Why it matters

Branching is what makes a program respond to its input at all

Without an if statement, a program would do exactly the same thing on every run regardless of what data it receives.

Loops remove the need to write out repeated logic by hand

Processing a thousand rows takes the same few lines as processing ten, because the loop, not the programmer, repeats the work.

Misreading control flow is one of the most common debugging failures

A bug that looks like wrong data is very often a loop that runs one time too many or too few, or a condition that is true when the programmer assumed it was false.

Short-circuit evaluation changes what actually executes, not just the result

In 'a and b', b is never evaluated if a is already false - code that relies on b running as a side effect will silently not run.

Branching: if, elif, and else

score = 82

if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
else:
    grade = 'F'

print(grade)  # B

Loops: known repetition vs repetition until a condition changes

total = 0
n = 1
while total < 50:
    total += n
    n += 1

print(total, n)  # the first total that reaches or passes 50, and the n that got it there

Nesting and early exits

Mistakes people make here

Off-by-one errors in loop bounds

range(1, 5) produces 1 through 4, not 5, because the stop value is exclusive. This is consistent with indexing starting at 0, but it still catches people who expect the endpoint to be included.

Writing a while loop that never updates its own condition

A while loop only stops when its condition becomes false; forgetting to change the variable the condition depends on produces an infinite loop that has to be killed from outside the program.

Nesting conditionals three or four levels deep instead of returning early

Each level of nesting adds a state the reader has to hold in their head simultaneously. A guard clause that handles the exceptional case first and exits usually reads more clearly than an equivalent deeply nested if.

Reaching for a while loop with a manual counter where a for loop already does the job

A for loop over range(n) or a collection cannot forget to update its own counter and cannot run one iteration too many by mistake - a hand-rolled while loop with an index variable can do both.

Strengths and trade-offs

Who needs this

Everyone who writes code, from the first program onward. It is also one of the few concepts where the underlying idea is identical across virtually every language, even when the exact syntax is not.

Questions about control flow: conditionals and loops

What's the real difference between a for loop and a while loop?

A for loop iterates over a known sequence and stops when it is exhausted; a while loop repeats based on a condition and can run zero times, a fixed number of times, or indefinitely depending on how that condition changes. Use for when you're iterating over something; use while when you're waiting for a state to change.

What's the difference between break and continue?

break exits the loop entirely, skipping any remaining iterations. continue skips only the rest of the current iteration and moves on to the next one, still checking the loop's condition normally.

Why do some languages skip evaluating the second half of an and or or?

It's called short-circuit evaluation: if the first operand of and is already false, the whole expression must be false regardless of the second operand, so evaluating it would be wasted work - and, in patterns that check a value exists before using it, actively unsafe to evaluate.

Is recursion a form of control flow?

Yes - a function calling itself is another way to repeat work, as an alternative to a loop. It's covered in more depth alongside functions, since it depends on understanding how function calls and scope work first.

The primary source

• Python tutorial: more control flow tools ↗