Lesson 5: Conditional Branches & Loops

Controlling Execution Flow

A program runs sequentially by default — top to bottom, one line after another. Conditionals and loops are what give your program the power to make decisions and repeat work. Together they turn a static script into dynamic, intelligent software.

Think about it this way: without conditionals, every run of a program produces the identical output, forever. Without loops, you would write the same line a thousand times to repeat a task a thousand times. These two tools are the difference between a calculator and a program.

What You'll Learn in This Lesson

• Route code with if / elif / else
• Understand truthiness — which values count as True or False
• Iterate with for loops over sequences and range()
• Loop with while until a condition becomes False
• Interrupt loops with break and continue

Truthiness — What Counts as True?

In Python, every value has a truth value. The following are always falsy:

Everything else is truthy — including negative numbers, the string "0", and empty sets. This lets you write terse checks like if items: (true when the list has anything in it).

Mental model: an empty container or a zero-like value "weighs nothing" and counts as False; anything with content or magnitude counts as True. When you see if x:, translate it as "if x has anything in it" or "if x is not zero".

Why Truthiness Matters in Real Code

Truthiness is what lets professional code avoid clumsy verbosity:

# Clumsy
if len(items) > 0:
    process(items)

# Pythonic — items being non-empty means True
if items:
    process(items)

The second version is shorter, reads naturally, and is the style used in virtually all real Python codebases — from Django to PyTorch.

Conditionals — The if / elif / else Chain

A conditional routes the code path based on a boolean expression:

score = 85

if score >= 90:
    print("Grade: A+")
elif score >= 75:
    print("Grade: B")
elif score >= 60:
    print("Grade: C")
else:
    print("Grade: F")

Key rules:

• Only ONE branch ever runs — Python checks from top to bottom and takes the first True branch, then skips the rest.
• elif means "else if" and can appear any number of times.
• else is optional and catches everything not caught above.
• Order matters: check the most specific condition first (90 before 75).

Decision-tree mental model: each if is a fork in the road. You walk down the first path whose sign says "True", and you never come back.

Nested Conditionals — Decisions Inside Decisions

An if block can contain another if — useful when a second decision only makes sense after the first:

age = 20
has_id = True

if age >= 18:
    if has_id:
        print("Welcome in!")
    else:
        print("Need ID")
else:
    print("Too young")

Nesting is fine up to two or three levels — beyond that, restructure with and/or or helper functions to keep code flat and readable.

The for Loop — Iterating Over Sequences

The for loop walks through every item of a sequence:

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

You can loop over strings, lists, tuples, dict keys, sets — anything iterable. For a range of numbers, use range():

range() has three forms:

Trace-table tip: write a small table with columns for the loop variable and the output. Step through each iteration — this is exactly what Python does.

Accumulating in a Loop — The Counter Pattern

The single most common loop task is accumulating a total:

total = 0
for n in range(1, 6):     # 1 + 2 + 3 + 4 + 5
    total += n
print(total)              # 15

Trace table for this loop:

This pattern — initialize before the loop, update inside — powers sums, counts, maximums, and building lists for the rest of the course.

The while Loop — Loop Until False

The while loop repeats as long as its condition is True:

count = 3
while count > 0:
    print(count)
    count -= 1
print("Blast off!")

Danger: if the condition never becomes False, the loop runs forever (an infinite loop). Always make sure something inside the loop moves the condition toward False.

Choosing between for and while:

break and continue — Loop Interrupts

for n in range(1, 11):
    if n % 3 == 0:
        continue          # skip multiples of 3
    if n == 8:
        break             # stop at 8
    print(n)              # 1 2 4 5 7

Mental model: break slams on the brakes and leaves the car. continue jumps over one pothole but keeps driving the same route.

Common Mistakes to Avoid

• Mistake: if score = 90: — Fix: comparison needs ==, not =.
• Mistake: An infinite while True: with no break — Fix: ensure the condition or a break eventually stops it.
• Mistake: Checking elif conditions in the wrong order (e.g., >= 60 before >= 90) — Fix: order from most to least specific.
• Mistake: Forgetting to update the loop variable in a while loop — Fix: an unchanged condition means an infinite loop.
• Mistake: Indenting the loop body inconsistently — Fix: every statement that belongs to the loop must share the same indent.

Professional Tips & Tricks

• Put the most likely condition first for slightly faster, clearer code.
• while True + break is a clean pattern for menus and input validation loops.
• range(start, stop, step) gives you full control over for-loop stepping.
• Use trace tables on paper for the first few loops — the muscle memory pays off forever.

Key Takeaways

• if/elif/else runs exactly one branch — first True wins.
• Truthiness lets you write if items: instead of if len(items) > 0:.
• for iterates over sequences; while repeats until False.
• break stops a loop; continue skips one iteration.
• Always ensure while loops can terminate.
• The accumulate-inside-a-loop pattern is the foundation of nearly every algorithm.

Next up: Loop control in depth — nested loops, the loop else clause, and pass.