Python Nested If Statements – Complete Guide with Examples

Basic Nested If Syntax

Any if/elif/else block can contain another if/elif/else block inside it. The inner block only runs if the outer condition is True.

age = 20
has_id = True

if age >= 18:
    print("Old enough")
    if has_id:
        print("Has ID — entry allowed")
    else:
        print("No ID — cannot enter")
else:
    print("Too young — entry denied")

Real-World Example – ATM Machine

Nested ifs naturally model real-world decision trees. An ATM checks multiple conditions in sequence.

is_logged_in = True
balance = 500
withdraw_amount = 200

if is_logged_in:
    if withdraw_amount > 0:
        if withdraw_amount <= balance:
            balance -= withdraw_amount
            print(f"Dispensing ${withdraw_amount}")
            print(f"Remaining balance: ${balance}")
        else:
            print("Insufficient funds")
    else:
        print("Enter a valid amount")
else:
    print("Please log in first")

Avoid Deep Nesting – Flatten with elif

Deep nesting (3+ levels) is hard to read and debug. Often you can flatten it using elif or early returns (guard clauses).

# ❌ Deep nesting (hard to follow)
if condition1:
    if condition2:
        if condition3:
            do_something()

# ✅ Flattened with elif
if condition1 and condition2 and condition3:
    do_something()

# ✅ Guard clause pattern (in functions)
def process(user, amount):
    if not user.is_logged_in:
        return "Not logged in"
    if amount <= 0:
        return "Invalid amount"
    if amount > user.balance:
        return "Insufficient funds"
    # Happy path — no nesting needed
    user.balance -= amount
    return f"Success: ${amount} processed"

Best Practices for Nested Ifs

1. Limit nesting to 2 levels maximum. 2. Use elif to flatten multi-condition checks. 3. Use guard clauses (early returns) in functions. 4. Extract complex conditions into named boolean variables for readability.

# ✅ Named boolean variables make nesting readable
is_adult = age >= 18
has_valid_id = id_number and len(id_number) == 10
is_member = user_type in ["gold", "silver", "bronze"]

if is_adult and has_valid_id:
    if is_member:
        apply_member_discount()
    process_order()

Nested Conditions — and How to Flatten Them

You can put ifs inside ifs, but deep nesting ("the arrow anti-pattern") gets unreadable fast. Two techniques flatten it: combining conditions, and early returns (guard clauses).

# ❌ deeply nested — hard to follow
def can_access(user):
    if user is not None:
        if user.active:
            if user.role == "admin":
                return True
    return False

# ✅ guard clauses — flat, reads top to bottom
def can_access(user):
    if user is None:      return False
    if not user.active:   return False
    if user.role != "admin": return False
    return True

The guard-clause pattern: handle the failure/exit cases first with early returns, so the "happy path" ends up unindented at the bottom. This eliminates nesting and makes each condition's purpose obvious.

Combine with boolean operators when conditions belong together: if user and user.active and user.role == "admin": — thanks to short-circuiting, if user is None, Python never evaluates user.active, so no crash. Reach for combined conditions when they're truly one check; use guard clauses when each failure needs different handling. Both beat a pyramid of nested ifs.

Interview Questions on Nested If Statements

• What is a nested if statement?
• What are the readability problems with deeply nested conditions?
• How can you flatten nested if statements?
• What is a guard clause and how does it reduce nesting?
• When is nesting if statements appropriate?
• What is the difference between nested if and elif chains?
• How do logical operators help avoid nesting?

Related Topics