Exercises — Nested conditionals

Answer: (B).

• (A) is if/elif — these are siblings at the same indentation lane, not one inside the other. No nesting.
• (B) has if b > 0: sitting indented inside the body of if a > 0:. That inner if only runs when the outer is True. This is the nest.
• (C) uses and to combine two conditions on one line. It behaves like (B) for a single outcome, but structurally it is a flat single if — no inner if. This is the "flatten with and" pattern from the parent note.

The else sits in the same lane (one indent deep) as if humid > 70:. So it pairs with if humid > 70. It is the inner else. Meaning: we only reach it after temp > 30 was already True, and then found humid > 70 was False → prints hot and dry.

• score >= 60? 85 >= 60 → True. Enter outer body; outer else is skipped.
• score >= 90? 85 >= 90 → False → take inner else.
• Output: Pass

Walk all three — covering every case the code can hit:

• n = 0: 0 >= 0 True → 0 == 0 True → zero.
• n = 7: 7 >= 0 True → 7 == 0 False → inner else → positive.
• n = -3: -3 >= 0 False → outer else → negative.

Notice: the outer gate splits sign; the inner gate only distinguishes zero-vs-positive inside the non-negative branch. The negative branch never asks the == 0 question — it can't be zero there.

• logged_in True → enter.
• banned True → Access denied, and we stop. The is_admin question is never asked — banned overrides everything inside this branch.
• Output: Access denied

This code is actually correct as written — the else sits in the same lane as if a > 0, so it pairs with the outer if. Trace it:

• a > 0 False → outer else → a not positive. ✅
• a > 0 True, b > 0 True → both positive. ✅
• a > 0 True, b > 0 False → nothing prints (the inner if has no else), which matches the spec ("only when a<=0" for the message). ✅

The lesson: the lane test confirms correctness. The else is one lane out, so it is the outer else. Don't be spooked by how close the else looks to if b > 0 — measure the lane, not the eyeball distance.

As written, else is on the outer lane, so it fires when a <= 0 — that is the dangling-else trap. To make else pair with if b > 0, push it one lane deeper so it sits in the inner body's lane:

if a > 0:
    if b > 0:
        print("both positive")
    else:
        print("inner else")

Now with a=1, b=-1: a>0 True → b>0 False → inner else. And with a=-5: a>0 False → nothing prints (there is no outer else anymore). Compare the two lane pictures below.

if x = 5: raises a SyntaxError. = is the assignment operator ("put 5 into x"); a condition needs a comparison. Fix:

if x == 5:
    print("five")

Now x == 5 asks "is x equal to 5?" → True → prints five. See Comparison operators.

Each check only makes sense after the previous passed — a textbook chain of gates:

if card_valid:
    if pin_ok:
        if amount > balance:
            print("Insufficient funds")
        else:
            print("Dispensing cash")
    else:
        print("Wrong PIN")
else:
    print("Card rejected")

Trace check with card_valid=True, pin_ok=True, amount=100, balance=500: valid → pin ok → 100 > 500? False → else → Dispensing cash. ✅

Trace with card_valid=True, pin_ok=False: valid → pin False → Wrong PIN (the amount check is never reached — you can't withdraw with a bad PIN). ✅

% is the remainder operator: n % 2 is what's left after dividing by 2, so it's 0 for even and 1 (or -1) for odd. We test == 0.

if n < 0:
    if n % 2 == 0:
        print("neg even")
    else:
        print("neg odd")
else:
    if n % 2 == 0:
        print("non-neg even")
    else:
        print("non-neg odd")

Cover all four buckets with n = -4, -3, 0, 7:

• -4: <0 True, -4 % 2 == 0 True → neg even.
• -3: <0 True, -3 % 2 == 0? In Python -3 % 2 == 1, so False → neg odd.
• 0: <0 False, 0 % 2 == 0 True → non-neg even.
• 7: <0 False, 7 % 2 == 0 False → non-neg odd. ✅

(Python's % always returns a result with the sign of the divisor 2, so -3 % 2 is 1, not -1. Testing == 0 for evenness is safe in every case.)

There is exactly one printed outcome (Can drive) and it appears only when both conditions hold. To prove two branchings behave identically we use a truth table: a grid that lists every possible combination of the input conditions and records what each version does. Here each condition is either T (True) or F (False), so with two conditions there are 2 × 2 = 4 rows — every situation the world can present.

Read the table like this: pick a row (a scenario), then follow across to see whether the nested code prints and whether the flat code prints. If those two answers agree in every row, the versions are provably equivalent.

The "prints?" columns are identical in all four rows, so the versions are equivalent. Because we produce only one message, flattening with and is the readable choice (see Code readability and refactoring and Boolean logic and operators). Keep nesting only when each level needs its own distinct branch/message.

Three nested gates with a single outcome and no else branches → flatten with and:

if a and b and c:
    print("all three")

What "short-circuits" means: short-circuit evaluation is when a Boolean operator stops as soon as the answer is certain, without looking at the remaining operands. For and, Python checks the left operand first; if it is falsy the whole and is already False, so Python returns immediately and never even evaluates what comes after. (Likewise or stops at the first truthy operand — see Boolean logic and operators.)

So a and b and c checks a first; if a is falsy it never evaluates b or c. That means the "don't ask the inner question unless the outer passed" safety of nesting is preserved — and gives the same laziness. Depth drops from 3 to 1. Only keep the nest if, say, you needed to print("a failed") at a level — then a branch message forces nesting.

Comparing None > 0 raises a TypeError in Python 3, so we must gate None out first — this is the "unsafe inner check" reason for nesting from the parent note:

if x is None:
    print("missing")
else:
    if x == 0:
        print("zero")
    elif x > 0:
        print("positive")
    else:
        print("negative")

Sweep every case:

• x = None: x is None True → missing (numeric block never runs — safe!).
• x = 0: not None → x == 0 True → zero.
• x = 42: not None → not 0 → 42 > 0 True → positive.
• x = -8: not None → not 0 → -8 > 0 False → else → negative.

The outer gate protects the inner comparisons. No input can reach x > 0 while x is None. Every case is covered and none crashes.

The five levels ::: L1 recognise a nest vs an elif chain; L2 trace outputs gate-by-gate over all cases; L3 fix dangling-else via the lane rule; L4 build nested logic from a spec; L5 prove equivalence, refactor arrow code, and gate unsafe operations. The single rule for else pairing ::: it binds to the nearest unmatched if in the same indentation lane. When to flatten with and ::: one single outcome and no per-level messages, and short-circuiting keeps inner checks safe. When to keep the nest ::: distinct messages per level, or an inner check that is unsafe unless the outer passed.