What "Nested" Means

A nested conditional is a conditional statement placed inside another conditional statement. The key rule is timing: the inner condition is only checked when the outer condition is true. If the outer condition is false, the entire inner conditional is skipped without ever being evaluated. Nesting is how a program asks a second question only after the first one has already been answered a certain way.

x = 3
if x > 5:
    if x > 1:
        print("deep")
print("done")

x <- 3
IF (x > 5)
{
    IF (x > 1)
    {
        DISPLAY("deep")
    }
}
DISPLAY("done")

Here the outer test x > 5 is false (x is 3), so the whole inner IF is skipped and never runs. The program jumps straight to print("done"). Reading nesting correctly means always resolving the outer condition first, then only descending into the inner block when the outer was true.

x = 3
if x > 5:
    if x > 1:
        print("deep")
print("done")

Multiway Selection: Choosing One of Many

Often you need more than two outcomes: a grade of A, B, C, or F; a shipping tier; a category. In Python this is an if followed by one or more elif branches and a final else. The rule that makes it work: Python checks the branches top to bottom and runs the first one whose condition is true, then skips all the rest. At most one branch ever runs.

x = 82
if x >= 90:
    print("A")
elif x >= 80:
    print("B")
else:
    print("C")

x <- 82
IF (x >= 90)
{
    DISPLAY("A")
}
ELSE
{
    IF (x >= 80)
    {
        DISPLAY("B")
    }
    ELSE
    {
        DISPLAY("C")
    }
}

With x at 82, the first condition x >= 90 is false, the second x >= 80 is true, so it prints B and stops. It never even checks the else. Notice the pseudocode on the right expresses the exact same logic as nested IF/ELSE, because the exam reference sheet has no elif. They are two spellings of one idea.

Order Matters: the Overlap Trap

Because a multiway chain runs the first true branch, the order of the conditions can change the result when the conditions overlap. If a broad condition is placed before a more specific one, the broad condition catches the value first and the specific branch becomes unreachable.

# WRONG order: broad test first
if x >= 50:
    print("big")
elif x >= 100:
    print("huge")
else:
    print("small")

# RIGHT order: specific test first
IF (x >= 100)
{
    DISPLAY("huge")
}
ELSE
{
    IF (x >= 50)
    {
        DISPLAY("big")
    }
    ELSE
    {
        DISPLAY("small")
    }
}

On the left, any value 100 or larger is also 50 or larger, so x >= 50 fires first and prints "big" even when the value deserved "huge." The specific case never gets a chance. The fix, shown on the right, is to test the most specific or most extreme condition first and let the broader ones follow.

if x >= 13:
    print("teen")
elif x >= 20:
    print("adult")

Tracing Nested and Multiway Code

Use one disciplined procedure and these questions become mechanical:

1. Evaluate the outer condition first using current values.
2. If it is false, skip the entire inner block, then continue after it. Do not peek inside.
3. If it is true, step into the inner conditional and evaluate it the same way.
4. For an if / elif / else chain, check conditions top to bottom and stop at the first true one.
5. Exactly one path through the structure runs. Trace only that path.

w = 5
if w > 0:
    if w > 10:
        print("big positive")
    else:
        print("small positive")
else:
    print("not positive")

w <- 5
IF (w > 0)
{
    IF (w > 10)
    {
        DISPLAY("big positive")
    }
    ELSE
    {
        DISPLAY("small positive")
    }
}
ELSE
{
    DISPLAY("not positive")
}

With w at 5: the outer w > 0 is true, so step inside. The inner w > 10 is false, so the inner else runs and it prints "small positive." The outer else is never considered because the outer condition was true.

x = 7
if x > 10:
    print("hi")
elif x > 5:
    print("mid")
else:
    print("lo")

Key Vocabulary