Control flow is the order in which statements execute. By default it is sequential, top to bottom, but two constructs bend it. Selection (if / elif / else) chooses a branch based on a boolean condition. Iteration (while, for) repeats a block. A remarkable theorem — the Böhm–Jacopini structured programming theorem (1966) — proves that sequence, selection and iteration are together sufficient to compute any computable function. You need nothing else.

A function is a named, reusable, parameterised block that takes arguments and returns a value. Functions provide abstraction (hide detail behind a name), reuse (write once, call many times), and scope (variables inside a function are local; they do not leak out). A function's name plus its parameters form its interface; its body is the hidden implementation.

Think of loops as controlled repetition with an invariant — a statement that stays true on every pass. A while loop keeps going until its condition fails; the programmer's duty is to guarantee the condition eventually becomes false, or the loop runs forever (an infinite loop). A for loop iterates a known collection, sidestepping that risk entirely — prefer it whenever the number of steps is known.

Functions are the primary weapon against complexity. A well-named function lets you reason about what it does without re-reading how. This is abstraction: sqrt(2) is meaningful even if you have never read its implementation. Scope enforces the boundary — a variable born inside a function dies when the function returns, keeping the outside world clean and predictable.

We will build a small toolkit: test primality with a loop, and use a while loop with the Collatz sequence — a famous, still-unproven conjecture that every start reaches 1.

def is_prime(n):
    if n < 2:
        return False                 # early exit: 0 and 1 are not prime
    i = 2
    while i * i <= n:                 # only test up to sqrt(n)  (an optimisation)
        if n % i == 0:               # divisible -> composite
            return False
        i = i + 1
    return True                      # no divisor found -> prime

def collatz_steps(n):
    """Count steps to reach 1 under the Collatz map (unproven to always halt)."""
    steps = 0
    while n != 1:                    # loop invariant: n is a positive integer
        if n % 2 == 0:
            n = n // 2               # even -> halve
        else:
            n = 3 * n + 1            # odd  -> triple plus one
        steps = steps + 1
    return steps

# for-loop drives a known range; function calls hide the detail
primes = [n for n in range(2, 30) if is_prime(n)]
print(primes)                        # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
print(collatz_steps(27))             # 111 steps to reach 1

The i*i <= n test is a genuine algorithmic insight: if n has a divisor larger than its square root, it must also have one smaller, so we can stop early. This single line turns an O(n) check into O(√n).