Python Control Flow: If Statements and Loops (2026)

Quick Answer: Python Control Flow

The Zeros That Vanished

A discount-processing function needs to apply a discount only to rows where one was actually recorded. The intuitive check:

discounts = {"order_1": 10, "order_2": 0, "order_3": None}

for order_id, discount in discounts.items():
    if discount:
        print(f"{order_id}: applying {discount}% discount")
    else:
        print(f"{order_id}: no discount")

# order_2 has a real 0% discount recorded — but it prints "no discount",
# identical to order_3, which genuinely has no discount data at all

if discount: doesn't ask "was a discount recorded" — it asks "is this value truthy," and 0 fails that test exactly the same way None does. The bug is invisible in the output: both rows print the same "no discount" message, even though one of them is a real, meaningful zero. The fix is being explicit about what you're actually checking, covered fully in the next section.

if / elif / else: The Anatomy

Python's conditional structure reads close to plain English, and indentation — not braces — defines which code belongs to which branch.

score = 72

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

print(grade)  # "C"

Python checks each condition top to bottom and stops at the first one that's true — the rest are never evaluated. elif is Python's word for "else if"; there's no separate keyword for it, and a chain can have as many elif branches as needed before an optional final else.

Truthy and Falsy Values: Fixing the Hook Bug

Every value in Python has an implicit boolean identity, even outside an explicit comparison — this is what if discount: was actually testing.

for order_id, discount in discounts.items():
    if discount is not None:   # checks specifically for missing data
        print(f"{order_id}: applying {discount}% discount")
    else:
        print(f"{order_id}: no discount data")

# now order_2 (discount=0) is correctly treated as "0% discount applied,"
# distinct from order_3, which genuinely has no data

is not None checks specifically for the absence of a value — it doesn't care whether the value happens to also be falsy for other reasons. This distinction matters anywhere zero, an empty string, or an empty list could be a legitimate, meaningful value rather than a stand-in for "missing."

for Loops: Iterating a Known Sequence

A for loop runs once per item in a sequence — a list, a string, a range of numbers, or a dictionary's keys.

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

# enumerate() gives you the index and the value together
for i, fruit in enumerate(fruits):
    print(i, fruit)

# range() for a fixed number of iterations
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

enumerate() replaces the manual pattern of tracking a separate counter variable and incrementing it by hand — reach for it any time both the position and the value are needed inside the loop body.

while Loops: Repeating Until a Condition Changes

A while loop keeps running as long as its condition stays true — the right tool when the number of iterations isn't known ahead of time.

attempts = 0
max_attempts = 3

while attempts < max_attempts:
    print(f"Attempt {attempts + 1}")
    attempts += 1

break and continue

Both alter a loop's normal flow, but in different directions: one exits, the other skips.

numbers = [4, 7, 2, 9, 1]

for n in numbers:
    if n == 9:
        break       # stop the loop entirely
    if n % 2 == 0:
        continue    # skip this iteration, move to the next
    print(n)     # prints 7, then 1 (skips 4 and 2, stops before 9)

The Loop-Mutation Trap

The other classic control-flow bug: removing items from a list while iterating over that same list.

numbers = [1, 2, 3, 4, 5]

# WRONG: removing while iterating skips elements
for n in numbers:
    if n % 2 == 0:
        numbers.remove(n)  # shifts remaining items, some get skipped

# CORRECT: build a new filtered list instead
numbers = [1, 2, 3, 4, 5]
numbers = [n for n in numbers if n % 2 != 0]

Removing an item shifts every element after it one position to the left — but the loop's internal position counter doesn't know that, so it skips the item that just slid into the spot it already passed. Building a new list (or looping over numbers.copy() instead of numbers directly) avoids the problem entirely.

Mistakes That Give Away a Beginner

• Using if value: when 0 or "" could be legitimate — the exact trap from this article's opening. Use is not None when that distinction matters.
• Removing items from a list while looping over it directly, silently skipping elements.
• Forgetting to update a while loop's condition variable, causing an infinite loop.
• Using break when continue was meant, exiting a loop entirely instead of just skipping one iteration.
• Manually tracking an index with a counter variable instead of reaching for enumerate().

Practice: Fix These Three Yourself

Frequently Asked Questions

Conclusion: Be Explicit About What You're Checking

Python's control flow syntax is simple; the bugs it hides are subtle. The one habit worth carrying forward from this article: a plain if value: check is a truthy test, not a "does this exist" test, and the two are only the same when zero, empty strings, and empty collections can never be legitimate values in your data — which, in real data science work, they very often are. Loop deliberately, never mutate what you're iterating over, and reach for is not None the moment that distinction actually matters.

Practice the three exercises above, then move to the next article in this cluster, which covers functions and scope — how to package this logic into reusable, well-behaved pieces.