Python Nested If

3Python Nested If: explained step by step

Some questions only make sense after an earlier one has been answered. You don't ask a passenger which seat they would like until you know they have a ticket. In code that means placing one if inside another: a nested if. The inner question is asked only when the outer condition is True.

An if inside an if

age = 20
has_ticket = True

if age >= 18:
    print("Age check passed")
    if has_ticket:
        print("Welcome in")
    else:
        print("Please buy a ticket first")
else:
    print("Adults only")

Every if / else pair is its own decision. The inner if sits one level deeper (four more spaces), and the inner else lines up with the inner if, so it belongs to it. The outer else, back at the left edge, belongs to the outer if. Try has_ticket = False, then age = 15, and watch which message appears.

Indentation is the structure

Python has no braces. The left edge of each line tells you which block it belongs to. To read nested code, find an else and look straight up for the if with exactly the same indentation: that is its partner.

if outer_question:
    if inner_question:
        ...      # outer True, inner True
    else:
        ...      # outer True, inner False
else:
    ...          # outer False: the inner question was never asked
print("done")    # back at the left edge: always runs

When nesting is the natural choice

Nest when the second question depends on the first, or when each answer to the first question leads to different follow-up questions. An elif ladder fits inside an if just as it does anywhere else. Here only members get a tiered discount, so non-members never even reach the ladder:

is_member = True
total = 85

if is_member:
    if total >= 100:
        discount = 20
    elif total >= 50:
        discount = 10
    else:
        discount = 5
else:
    discount = 0
print(f"Discount: {discount}%")

Flattening with and

When an outer if contains nothing but one inner if, and neither has an else, you can merge the two tests with and. These two blocks do exactly the same thing:

age = 20
has_ticket = True

if age >= 18:
    if has_ticket:
        print("Nested: welcome in")

if age >= 18 and has_ticket:
    print("Flat: welcome in")

The flat version is shorter. Keep the nesting when you want to say which test failed: "Adults only" and "Please buy a ticket first" are different messages, and a single and can't tell them apart.

Check the problems first

Deeply nested code drifts further and further to the right, which makes it hard to follow. A calmer layout deals with the unhappy cases first, one per line, and leaves the normal case for the end. With elif it looks like this:

age = 20
has_ticket = False
is_banned = False

if is_banned:
    print("Entry refused")
elif age < 18:
    print("Adults only")
elif not has_ticket:
    print("Please buy a ticket first")
else:
    print("Welcome in")

Inside a function there is an even neater version. Each check ends with return, which hands back an answer and leaves the function immediately, so the code never gets deeper than one level. This is called a guard clause:

def entry_message(age, has_ticket):
    if age < 18:
        return "Adults only"
    if not has_ticket:
        return "Please buy a ticket first"
    return "Welcome in"

How deep is too deep?

Two levels are normal. At three, look for a simpler shape. Beyond that, flatten with and, check the problems first, or move the inner part into its own function. And if the outer question has many possible answers instead of yes/no, a match statement may express it better.