Decision Making with if, elif and else

1. Introduction to Program Control Flow

By default, the Python interpreter executes code sequentially—line by line, from top to bottom. However, real-world software applications cannot rely solely on linear execution. Programs need to make dynamic decisions, adapt to changing runtime conditions, validate user inputs, process permissions, and execute specific code blocks while ignoring others based on Boolean evaluation.

The mechanism that allows a program to branch its execution path is known as Control Flow. In Python, conditional branching is primarily achieved using the conditional control statements: if, elif (short for else if), and else.

2. The Single Branch: The `if` Statement

1. Mechanics and Syntax

The if statement is the simplest form of decision-making. It evaluates a Boolean condition expression. If the expression evaluates to True (or a Truthy object), the indented code block beneath it is executed. If the expression evaluates to False (or a Falsy object), Python completely skips the indented block and continues execution on the next line outside the block.

# Syntax Structure of a basic if statement:
if conditional_expression:
    # Code block executed ONLY if conditional_expression evaluates to True
    statement_1
    statement_2
    

user_balance = 500.00
withdrawal_amount = 150.00

print("System Initializing Transaction...")

# Check if balance is sufficient
if user_balance >= withdrawal_amount:
    user_balance -= withdrawal_amount
    print("Transaction Approved!")
    print(f"Remaining Balance: ${user_balance:.2f}")

print("Transaction Processing Complete.")

System Initializing Transaction...
Transaction Approved!
Remaining Balance: $350.00
Transaction Processing Complete.

3. Dual Branching: The `if-else` Statement

1. Fallback Logic

When you need a program to execute one action when a condition is met, and a completely different fallback action when that condition fails, combine if with an else block.

# Syntax Structure of an if-else statement:
if condition:
    # Executed if condition is True
    true_action_block
else:
    # Executed if condition is False
    false_action_block
    

user_age = 16

if user_age >= 18:
    print("Access Granted: Eligible for Voting.")
else:
    years_left = 18 - user_age
    print("Access Denied: Ineligible for Voting.")
    print(f"You will be eligible in {years_left} year(s).")

Access Denied: Ineligible for Voting.
You will be eligible in 2 year(s).

4. Multi-Branching Logic: The `if-elif-else` Ladder

When software decisions involve more than two mutually exclusive outcomes (such as grade calculations, pricing tiers, or user permission levels), chained branching becomes necessary. Python provides the elif keyword to test multiple conditions sequentially.

1. Execution Lifecycle of an `elif` Chain

1. Python tests the initial if condition first.
2. If it is True, its associated code block executes, and Python **skips all subsequent `elif` and `else` blocks in the chain**!
3. If it is False, Python evaluates the first elif condition.
4. Python proceeds down the ladder testing each elif line by line until it finds a condition that evaluates to True.
5. If **none** of the conditions in the ladder evaluate to True, the code inside the catch-all else block executes (if an else block is present).

score = 85

print(f"Evaluating Student Score: {score}")

if score >= 90:
    grade = "A+"
elif score >= 80:
    grade = "A"
elif score >= 70:
    grade = "B"
elif score >= 60:
    grade = "C"
elif score >= 50:
    grade = "D"
else:
    grade = "F (Fail)"

print(f"Final Academic Grade Assigned: {grade}")

Evaluating Student Score: 85
Final Academic Grade Assigned: A

5. Independent `if` Statements vs `if-elif` Chains

A frequent point of confusion for beginners is deciding whether to write a series of separate, independent if statements or link them into a single if-elif chain.

• Multiple Independent `if` Statements
• Python evaluates **every single condition** sequentially, regardless of whether prior conditions evaluated to True or False.
• When multiple non-mutually-exclusive conditions can be true simultaneously (e.g., checking multiple independent feature flags).
• Single `if-elif-else` Chain
• Python stops evaluation immediately after finding the **first True condition**. All remaining blocks are skipped.
• When conditions are mutually exclusive (e.g., calculating tax bracket tiers or status codes).

number = 15

print("--- Scenario A: Multiple Independent 'if' Statements ---")
if number > 5:
    print("Check 1: Number is greater than 5")
if number > 10:
    print("Check 2: Number is greater than 10")
if number > 20:
    print("Check 3: Number is greater than 20")

print("\n--- Scenario B: Single 'if-elif' Chain ---")
if number > 5:
    print("Chain 1: Number is greater than 5")
elif number > 10:
    print("Chain 2: Number is greater than 10")
elif number > 20:
    print("Chain 3: Number is greater than 20")

--- Scenario A: Multiple Independent 'if' Statements ---
Check 1: Number is greater than 5
Check 2: Number is greater than 10

--- Scenario B: Single 'if-elif' Chain ---
Chain 1: Number is greater than 5

6. Nested Conditional Statements

A conditional statement can be placed inside the body block of another conditional statement. This is known as a Nested Conditional.

account_active = True
account_balance = 1200.00
withdrawal_request = 500.00
is_atm_online = True

if is_atm_online:
    print("ATM Status: Online")
    if account_active:
        print("Account Verification: Active")
        if account_balance >= withdrawal_request:
            account_balance -= withdrawal_request
            print("Dispensing Cash...")
            print(f"Updated Balance: ${account_balance:.2f}")
        else:
            print("Transaction Declined: Insufficient Funds.")
    else:
        print("Transaction Declined: Account Frozen/Inactive.")
else:
    print("System Error: ATM Currently Offline.")

ATM Status: Online
Account Verification: Active
Dispensing Cash...
Updated Balance: $700.00

Avoiding Deep Nesting ("Arrow Anti-Pattern")

Deeply nested code blocks (indenting 4 or 5 levels deep) create unmaintainable, hard-to-read code known as the Arrow Anti-Pattern. You can flatten deeply nested conditionals by combining logic using Logical Operators (`and`/`or`) or by using early guard clauses.

# Clean, flattened alternative using compound boolean expressions
if is_atm_online and account_active and account_balance >= withdrawal_request:
    account_balance -= withdrawal_request
    print("Dispensing Cash... Updated Balance:", account_balance)
else:
    print("Transaction Failed: Check ATM Status, Account Activity, or Balance.")

Dispensing Cash... Updated Balance: 700.0

7. The Conditional Expression (Ternary Operator)

Python provides a compact, single-line syntax for evaluating a condition and assigning a value based on the result. This is known as the Conditional Expression or Ternary Operator.

1. Syntax and Expression Structure

value_if_true if condition else value_if_false

age = 20

# Standard multiline if-else:
if age >= 18:
    status = "Adult"
else:
    status = "Minor"

# Compact single-line Ternary Operator equivalent:
status_ternary = "Adult" if age >= 18 else "Minor"

print("Standard Status Assignment:", status)
print("Ternary Status Assignment :", status_ternary)

# Using ternary inline inside an f-string:
number = 7
print(f"The number {number} is {'Even' if number % 2 == 0 else 'Odd'}.")

Standard Status Assignment: Adult
Ternary Status Assignment : Adult
The number 7 is Odd.

8. Common Conditional Pitfalls and Syntax Bugs

1. Conflating Assignment (`=`) with Comparison (`==`)

In languages like C/C++, writing if (x = 5) accidentally assigns 5 to x and evaluates to True. Python explicitly prevents this bug at the parser level—attempting assignment inside an if condition triggers an immediate SyntaxError.

# Invalid Code in Python:
if x = 10:  # SyntaxError: invalid syntax. Maybe you meant '==' or ':='?
    print("Equal")
    

2. The `pass` Statement Placeholder

Because Python relies on indentation to define code blocks, an empty code block causes an IndentationError. If you are drafting control flow structure and wish to leave a block temporarily empty, use the pass keyword (a null-operation statement).

server_status = 500

if server_status == 200:
    print("Server OK")
elif server_status == 500:
    # TODO: Implement error reporting notification logic
    pass  # Prevents IndentationError
else:
    print("Unknown Error")

print("Script execution completed without indentation errors.")

Script execution completed without indentation errors.

9. Frequently Asked Interview Questions with Answers

10. Homework & Practical Assignment

11. File & Workspace Directory Structure

python_mastery_course/
│
├── lesson_01/
├── lesson_02/
├── lesson_03/
├── lesson_04/
├── lesson_05/
├── lesson_06/
├── lesson_07/
├── lesson_08/
├── lesson_09/
├── lesson_10/
│
└── lesson_11/
    ├── basic_if_statement.py
    ├── if_else_demo.py
    ├── grade_calculator.py
    ├── independent_vs_elif.py
    ├── nested_conditional_demo.py
    ├── flattened_logic.py
    ├── ternary_operator_demo.py
    ├── pass_placeholder.py
    ├── shipping_calculator.py
    ├── leap_year.py
    └── number_analyzer.py
        

12. What We Will Learn Next