Control Flow

Why it matters

Every program beyond the most trivial has to decide what to do — branch on a condition, repeat until something is true, stop early once an answer is found. Python’s control-flow tools cover all of that, but two of them (for/while’s else clause, and truthiness) behave in ways that surprise people coming from other languages, or coming to programming for the first time. Getting comfortable with both now avoids re-learning them the hard way later.

Mental model

Statements run top to bottom by default; if/elif/else and match pick exactly one branch to run instead of falling through all of them; for and while repeat a block, and both can end early with break or skip to the next iteration with continue.

Truthiness is what lets if items: work without spelling out if len(items) > 0:. Python treats a small, fixed set of values as falsy in a boolean context — everything else is truthy:

Worked example: guard clauses, a surprising loop else, and match

def validate_age(age: int) -> str | None:
    if age < 0:
        return "Age cannot be negative."
    if age > 150:
        return "That doesn't look like a real age."
    return None


def find_first_negative(numbers: list[int]) -> int | None:
    for number in numbers:
        if number < 0:
            found = number
            break
    else:
        found = None
    return found


def describe_status(code: int) -> str:
    match code:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500:
            return "Server Error"
        case _:
            return "Unknown"


def main() -> None:
    for age in [-5, 200, 30]:
        error = validate_age(age)
        print(f"{age}: {error or 'valid'}")

    print(find_first_negative([4, 7, -2, 9]))
    print(find_first_negative([4, 7, 2, 9]))

    for code in [200, 404, 999]:
        print(f"{code} -> {describe_status(code)}")


if __name__ == "__main__":
    main()

-5: Age cannot be negative.
200: That doesn't look like a real age.
30: valid
-2
None
200 -> OK
404 -> Not Found
999 -> Unknown

validate_age is a guard clause in action: each invalid case returns immediately, so the function never needs an else or nested if to express “otherwise, it’s fine.” error or 'valid' leans on truthiness directly — a non-empty error message is truthy and wins; None is falsy, so 'valid' is used instead.

find_first_negative is the canonical use of a loop’s else: it runs only when the for finishes without hitting break — see for/while…else for exactly what that checks (it is not the same thing as an if/else, despite sharing the keyword).

describe_status uses match to compare one value against several literal possibilities, ending in a wildcard case _: catch-all — a reasonable alternative to an if/elif chain here, though not a requirement; either reads fine for this specific case.

Common mistakes

• Nesting an if inside an if inside an if instead of using guard clauses — each level of nesting makes the “normal” logic harder to find; returning early for edge cases keeps it flat.
• Reading a loop’s else as “if the condition was ever false,” by analogy with if/else. It actually means “the loop finished without break” — a completely different check.
• Writing if is_valid == True: instead of if is_valid: — the comparison is redundant and, worse, actively wrong if is_valid could ever be a truthy non-boolean value instead of literally True.

Check your understanding

Practice: warm-up

Predict, then check: what does bool("False") return? Explain why in one sentence, using the truthiness rules above rather than guessing from the text inside the string.

bool("False") -> True

Practice: apply it

Write a small validation pipeline: a function validate_username(name: str) -> list[str] that returns a list of problem messages (empty list means valid) — check for empty input, length under 3, and length over 20, using guard clauses rather than nested ifs.

Summary

• Truthiness lets if value: work directly — only 0, 0.0, "", empty collections, None, and False are falsy; everything else, including the string "False", is truthy.
• A loop’s else clause runs when the loop finishes without hitting break — including the edge case of an empty iterable that never runs the loop body at all. It has nothing to do with if/else’s meaning of the word.
• match compares one subject against a sequence of patterns and requires Python 3.10+; for simple literal-value branching, it’s an alternative to if/elif, not a strict improvement.
• Guard clauses (early returns for edge cases) keep the common-case logic at a shallow, readable indentation level instead of nesting it inside else blocks.