Multiple & Nested Conditionals

Quick review: Boolean values

is_raining = True               # a Boolean value
score = 82
passed = score >= 70            # passed holds True

if passed:
    print("Nice work!")

Naming Boolean variables

Good Boolean names read like a yes/no question, so the if line reads like a sentence:

• is_raining, has_key, can_vote, passed
• if has_key: reads as "if (the player) has (the) key."

Avoid names that do not sound like a question, like key or rain. A reader cannot tell whether they hold True/False, a number, or a string.

Why store a condition? It gives a long condition a short, meaningful name, and you can reuse it: can_ride = height >= 48 and age >= 10, then if can_ride: anywhere later.

and & or

How to fill in a truth table quickly

• For and: find the one row where both are True. That row is True; every other row is False.
• For or: find the one row where both are False. That row is False; every other row is True.

Python takes shortcuts

Python stops checking as soon as it knows the answer. This is called short-circuit evaluation:

• False and ... is False no matter what comes next, so Python skips the right side.
• True or ... is True no matter what, so Python skips the right side.

This can prevent errors. In x != 0 and 10 / x > 2, if x is 0, the left side is False, so Python never tries to divide by zero.

not flips the answer

is_raining = False
if not is_raining:
    print("Let's go to the park!")

Flipping a whole and or or

Putting not in front of a combined condition flips both parts and swaps the joining word. This is called De Morgan's law:

In words: "It is not sunny and warm" means at least one of them is missing. "You have neither cash nor card" means both are missing.

Watch the precedence: not grabs only what is right next to it. not a and b means (not a) and b. To flip a whole expression, wrap it in parentheses.

Order of operations

Solving one by hand

With age = 15 and member = False, work out age > 12 and age < 18 or member:

age > 12 and age < 18 or member
# = True and True or False      comparisons first
# = True or False               and before or
# = True                        or last

Each line replaces one part with its value. Work slowly and you will get the same answer as Python every time.

Parentheses can fix a bug

Rule for a roller coaster: riders must be at least 48 inches tall, and they must be 10 or older or riding with an adult. The rider below is 40 inches tall. Run both versions.

Reading the rule out loud helps

When a sentence has an "and" and an "or," listen for which words belong together. "At least 48 inches tall, and (10 or older or with an adult)." The part in the pause is the part that needs parentheses.

Test the case that should fail

Both versions let a tall 12-year-old ride, so testing only with "good" riders would never find this bug. The bug only shows with a rider who breaks a rule, like the short rider with an adult. Always ask: "Who should be turned away? Does my program turn them away?"

Checking a range of values

if x >= 1 and x <= 10:
    print("In range")

if 1 <= x <= 10:
    print("In range")

if x < 1 or x > 10:
    print("Out of range")

Why and for inside, or for outside?

Picture a number line from 1 to 10. To be inside, a number has to pass two tests at once: not too small and not too big. To be outside, failing either test is enough: too small or too big.

Inside vs. outside are opposites: not (1 <= x <= 10) gives the same answer as x < 1 or x > 10.

The or trap

This program should only say "Nice!" for red or blue. Type green and run both versions.

Another way to fix it: in

When you are checking one variable against several possible values, in with a list is shorter and avoids the trap completely:

if color in ["red", "blue"]:
    print("Nice!")

This reads as "if color is one of red or blue," which is exactly what we meant.

Why is "blue" treated as True? Python lets any value be used as a condition. Empty things ("", 0) count as False, and everything else counts as True. So a non-empty string by itself is always "true enough."

Multiple separate if statements

How to decide in one question

Ask: "If this one is True, should Python still check the next one?"

• Yes: separate ifs. Cold and rainy means jacket and umbrella.
• No: an elif chain. If the grade is already an A, Python should not also give a B.

A useful test: with separate ifs, try values that make none true, one true, and all true. Every combination should give a sensible result.

elif chains with complex conditions

Trace age 70, not a student

1. age < 13 or age >= 65: False or True is True, so the price is $8.
2. The rest of the chain is skipped.

Trace age 16, a student

1. age < 13 or age >= 65: False or False is False. Move on.
2. The student check is True, so the price is $10.

The order sets the rules. Because the age discount comes first, a 10-year-old student pays $8, not $10. If the theater wanted students to always pay $10, the student check would have to come first.

Nested if: a decision inside a decision

if username == "coder1":
    if password == "py123":
        print("Welcome back!")
    else:
        print("Wrong password.")
else:
    print("User not found.")

Why nest instead of using and?

You could write if username == "coder1" and password == "py123":, but then a failed login could only say "Login failed." Nesting lets the program know which check failed, so it can give a specific message. Each else answers a different question.

Reading nested code

• Find the outer if at the left. Its body is everything indented under it.
• Inside that body is a complete, smaller if/else. Read it as its own little program.
• The outer else lines up with the outer if, so it answers the username question.

Real apps usually show the same "username or password is wrong" message for both, so attackers cannot learn which usernames exist. We use separate messages here so you can see each path.

Try it: nested login

The correct username is coder1 and the password is py123. Try all three paths: correct login, correct username with a wrong password, and a wrong username.

Plan your tests before you click

A nested if with an else at each level has one path per row. Testing each row once is called testing every path.

Nesting a whole if-elif-else

Read it as two separate decisions

1. Outer question: does the player have the key? If not, nothing else matters.
2. Inner question (only with the key): which level range are they in? Exactly one door opens, because it is an if-elif-else chain.

Counting the paths: 3 inner choices plus 1 "no key" path makes 4 possible outcomes. That is why the slide asks for four tests.

Indentation check: the inner if, elif, and else all line up with each other (4 spaces). Their bodies are at 8 spaces. The outer else is back at 0.

Nested if or and?

These two programs do the same thing:

if has_ticket:
    if age >= 13:
        print("Enjoy the movie!")

if has_ticket and age >= 13:
    print("Enjoy the movie!")

When you only care if both are True, the and version is shorter and easier to read. But nesting is the better choice when each "no" needs its own message:

if has_ticket:
    if age >= 13:
        print("Enjoy the movie!")
    else:
        print("This movie is PG-13. Pick another one.")
else:
    print("Please buy a ticket first.")

How they turn into each other

An outer if whose only content is an inner if (and no else anywhere) can always be flattened: just join the two conditions with and. Once you add an else with its own message, flattening would lose information, so nesting is the clearer choice.

Which if owns the else?

In nested code, an else belongs to the if it lines up with. Moving an else 4 spaces changes the whole meaning. Both programs use x = 3.

x = 3
if x > 0:
    if x > 5:
        print("big")
    else:
        print("small")

x = 3
if x > 0:
    if x > 5:
        print("big")
else:
    print("negative or zero")

Python decides by indentation only

Python never guesses based on what makes sense. An else belongs to whichever if has exactly the same indentation above it, with nothing at a smaller indentation in between. Moving it 4 spaces gives it a new partner and a new meaning.

Try x = -2 in both programs

• Left: -2 > 0 is False, so the whole outer body (including the inner else) is skipped. Nothing prints.
• Right: -2 > 0 is False, so the outer else runs: negative or zero.

Common mistakes

Error messages shown are from Python 3.13. Older versions word some messages a little differently. Notice that half of these mistakes give no error at all. That is why testing with many different values is so important.

How to find a logic error

1. Write down what should happen for a few inputs before you run anything.
2. Run each input and compare. The first one that does not match tells you which path is broken.
3. Step through (or add a print() of the condition, like print(color == "red" or "blue")) to see exactly what Python calculated.
4. Check the usual suspects: half comparisons, missing parentheses, and else at the wrong level.

Check yourself

Predict the answer, then click Check. This is practice only. Nothing is graded or recorded.

Cheat sheet

a and b     # True if both are True
a or b      # True if at least one is
not a       # flips True / False
1 <= x <= 10   # x is from 1 to 10

if temp < 60:
    print("jacket")
if is_raining:
    print("umbrella")

if has_key:
    if level >= 5:
        print("Door opens")
    else:
        print("Level up")
else:
    print("Find the key")

Before you run your code, check:

• Each side of and / or is a complete comparison
• Parentheses group the parts that belong together
• and, or, not, True, False are spelled correctly (only True/False are capitalized)
• Each else lines up with the if it belongs to
• Separate ifs for independent questions, elif when only one choice should happen
• You tested every path, including edge values

Key words to know

Boolean expression · and / or / not · truth table · precedence · short-circuit evaluation · chained comparison (1 <= x <= 10) · nested if · logic error · testing every path