Control Flow — if / elif / else

age = 20

if age < 13:
    print("Child")
elif age < 20:
    print("Teenager")
elif age < 65:
    print("Adult")
else:
    print("Senior")

# Output: Adult

if age >= 18: print("Adult")

# Preferred, even for one line — clearer, and trivially extensible:
if age >= 18:
    print("Adult")

False
None
0            # the integer zero
0.0          # the float zero
""           # an empty string
[]           # an empty list
{}           # an empty dict
()           # an empty tuple
set()        # an empty set

# Everything else is truthy — including "0" (a non-empty string!), [0], and -1

items = []

if items:
    print(f"You have {len(items)} items")
else:
    print("Your list is empty")

# Equivalent to, but more idiomatic than:
if len(items) > 0:
    ...

age = 20
status = "Adult" if age >= 18 else "Minor"

# Equivalent to the longer form:
if age >= 18:
    status = "Adult"
else:
    status = "Minor"

count = 3
print(f"You have {count} item{'s' if count != 1 else ''}")
# "You have 3 items" — correctly pluralised in a single line

result = max(0, value if value > 0 else 0)  # inside a function call argument

def process_order(order):
    if order is not None:
        if order.is_paid:
            if order.items:
                if order.shipping_address:
                    return "Ready to ship"
                else:
                    return "Missing shipping address"
            else:
                return "No items in order"
        else:
            return "Payment required"
    else:
        return "No order provided"

def process_order(order):
    if order is None:
        return "No order provided"
    if not order.is_paid:
        return "Payment required"
    if not order.items:
        return "No items in order"
    if not order.shipping_address:
        return "Missing shipping address"

    return "Ready to ship"

# Nested — unnecessary, since both checks lead to the same single outcome
if age >= 18:
    if has_id:
        print("Entry allowed")

# Flat — identical behaviour, easier to read
if age >= 18 and has_id:
    print("Entry allowed")

def describe_status(code):
    match code:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500 | 502 | 503:
            return "Server Error"
        case _:
            return "Unknown status"

describe_status(404)   # "Not Found"
describe_status(502)   # "Server Error" — the | matches multiple values in one case
describe_status(999)   # "Unknown status" — the _ is a wildcard, matching anything

def handle_event(event):
    match event:
        case {"type": "click", "x": x, "y": y}:
            return f"Click at ({x}, {y})"
        case {"type": "keypress", "key": key}:
            return f"Key pressed: {key}"
        case {"type": type_name}:
            return f"Unhandled event type: {type_name}"
        case _:
            return "Not a recognised event"

handle_event({"type": "click", "x": 10, "y": 20})
# "Click at (10, 20)" — x and y are extracted from the dict automatically

def classify_point(point):
    match point:
        case (0, 0):
            return "Origin"
        case (x, 0):
            return f"On the x-axis at {x}"
        case (0, y):
            return f"On the y-axis at {y}"
        case (x, y) if x == y:
            return "On the diagonal"
        case (x, y):
            return f"Point at ({x}, {y})"

classify_point((3, 3))    # "On the diagonal" — the "if" after a case is a guard condition

def calculate_discount(price, percent):
    assert 0 <= percent <= 100, f"Invalid discount percent: {percent}"
    return price * (1 - percent / 100)

calculate_discount(100, 20)     # 80.0 — fine
calculate_discount(100, 150)    # AssertionError: Invalid discount percent: 150

def function_to_implement_later():
    pass   # a stub — the function exists and is callable, but does nothing yet

if condition:
    pass    # deliberately no action for this case
else:
    do_something()

A new engineer submits a function that determines a shipment's status message based on its delivery state — a genuinely reasonable first attempt at the logic.

def get_status_message(shipment):
    if shipment is not None:
        if shipment.is_delivered == True:
            if shipment.signature_received == True:
                message = "Delivered and signed for"
            else:
                if shipment.left_at_door == True:
                    message = "Delivered — left at door"
                else:
                    message = "Delivered"
        else:
            message = "In transit"
    else:
        message = "Shipment not found"
    return message

What the reviewer flags

Three separate issues, each directly traceable to earlier parts of this module: the deep nesting is a textbook case for guard clauses (Part 04); every == True comparison should simply be the condition itself, since shipment.is_delivered is already a boolean (a truthiness-check idiom, Part 02); and the logic can be flattened entirely into ordered elif branches, since these are genuinely mutually exclusive outcomes, not independent nested decisions.

def get_status_message(shipment):
    if shipment is None:
        return "Shipment not found"
    if not shipment.is_delivered:
        return "In transit"
    if shipment.signature_received:
        return "Delivered and signed for"
    if shipment.left_at_door:
        return "Delivered — left at door"
    return "Delivered"

Same behaviour, eight lines shorter, and every branch is readable in isolation without mentally tracking four levels of nested indentation. This exact transformation — flatten nested conditionals, drop redundant == True comparisons, use guard clauses for early exits — is quite possibly the single most common category of feedback given in real Python code review for engineers early in their career.