Conditional Statements

Now that you understand boolean values, let us learn the actual keywords that make conditionals work: if, elif, and else. These are the building blocks you will use thousands of times in your programming journey!

These three keywords work together like a flowchart with decision points. You start by checking the if condition. If it fails, you check each elif condition in order. If they all fail, the else block runs as a catch-all. Only ONE of these blocks will ever run - as soon as Python finds a true condition, it runs that block and skips all the rest.

The Basic if Statement

Let us start with the simplest conditional: the if statement. It is exactly what it sounds like - "if something is true, do this."

if condition:
    # This code runs only if
    # condition is True
    do_something()

If the condition is True, Python runs the indented code. If the condition is False, Python skips it completely and moves on. Let us see a real example:

# Basic if statement syntax
age = 20

if age >= 18:
    print("You are an adult")
    print("You can vote in elections")

print("This always prints, regardless of age")

# Output:
# You are an adult
# You can vote in elections
# This always prints, regardless of age

Notice the colon (:) after the condition and the indentation of the code block. Python uses indentation (typically 4 spaces) to define code blocks, unlike languages that use curly braces. The indented lines belong to the if statement and only execute when the condition is true.

The standard convention in Python is to use 4 spaces for each level of indentation. While you can technically use tabs or a different number of spaces, mixing tabs and spaces will cause errors, and the Python community strongly recommends 4 spaces. Most code editors can be configured to insert 4 spaces when you press the Tab key.

The if-else Statement

Syntax Structure

# Basic if-else syntax structure
if condition:
    # This block runs when condition is True
    # Can have multiple lines
    # All lines must be indented
else:
    # This block runs when condition is False
    # Also can have multiple lines
    # Also must be indented

Practical Example

# if-else statement - Weather Decision
temperature = 15

if temperature >= 25:
    print("It is warm outside")
    print("Wear light clothes")
else:
    print("It is cool outside")
    print("Consider wearing a jacket")

# Output (since temperature is 15):
# It is cool outside
# Consider wearing a jacket

The else block catches all cases where the if condition fails. Think of it as a safety net - if the main condition is not met, the program falls through to the else block.

Example: Random Number Decision

# Example showing if-else guarantees one block executes
import random

number = random.randint(1, 10)

if number > 5:
    print(f"{number} is greater than 5")
else:
    print(f"{number} is 5 or less")

# One of these messages will ALWAYS print, never both, never neither

The if-elif-else Chain

When you have multiple conditions to check, use elif (short for "else if"). This lets you create a chain of conditions where Python checks each one in order and executes the first block whose condition is True.

# if-elif-else chain for grade classification
score = 78

if score >= 90:
    grade = "A"
    message = "Excellent work!"

elif score >= 80:
    grade = "B"
    message = "Good job!"

elif score >= 70:
    grade = "C"
    message = "Satisfactory"

elif score >= 60:
    grade = "D"
    message = "Needs improvement"
else:
    grade = "F"
    message = "Please see instructor"

print(f"Score: {score}")
print(f"Grade: {grade}")
print(f"Feedback: {message}")

In this example, even though score >= 70 and score >= 60 are both true (78 satisfies both), only the first matching condition executes. Once Python finds a true condition, it skips all remaining elif and else blocks.

Common Mistake: Wrong Order

The order of your conditions matters enormously! Here is a comparison:

score = 95

if score >= 60:    # True for 95!
    grade = "D"    # WRONG!
elif score >= 70:
    grade = "C"
elif score >= 80:
    grade = "B"
elif score >= 90:
    grade = "A"    # Never reached!

# Result: grade = "D" (Wrong!)

score = 95

if score >= 90:    # Most specific first
    grade = "A"    # Catches 90+
elif score >= 80:
    grade = "B"    # Catches 80-89
elif score >= 70:
    grade = "C"    # Catches 70-79
elif score >= 60:
    grade = "D"    # Catches 60-69

# Result: grade = "A" (Correct!)

Multiple Independent Conditions

Sometimes you need to check conditions that are independent of each other - where multiple conditions could all be true and you want to act on each one. In this case, use separate if statements instead of elif.

# Multiple independent conditions (not elif!)
user_age = 25
user_income = 60000
has_good_credit = True

We set up three variables to represent a loan applicant's profile. Each variable stores different information: age (25 years), annual income ($60,000), and credit status (good credit). These will be checked independently.

print("Loan eligibility check:")

This prints a header message to introduce what the program is doing. It helps make the output clear and organized for the user.

# Each condition is checked independently
if user_age >= 18:
    print("- Age requirement: PASSED")

The first if statement checks if the user is at least 18 years old. Since user_age is 25, this condition is True and the message prints. Notice this is a standalone if, not connected to the others.

if user_income >= 50000:
    print("- Income requirement: PASSED")

The second if statement checks if income is at least $50,000. This is a completely separate check from the age check. Both can pass, both can fail, or any combination. Since income is $60,000, this also passes.

if has_good_credit:
    print("- Credit requirement: PASSED")

The third if checks the credit status. Since has_good_credit is already a boolean (True), we don't need to compare it to anything. Python evaluates it directly. This also passes.

# All three conditions are checked separately
# Output:
# Loan eligibility check:
# - Age requirement: PASSED
# - Income requirement: PASSED
# - Credit requirement: PASSED

The key point: all three messages printed because each if statement runs independently. If we had used elif instead, only the first passing condition would have printed. Use multiple ifs when you want to check and act on multiple conditions separately.

Unlike an elif chain where only one block executes, here each if statement is evaluated independently. This is useful when you need to check multiple unrelated conditions or perform multiple actions.

Quick Reference: Conditional Structures

age = 17

if age >= 18:
    print("You are eligible to vote!")
elif age >= 16:
    print(f"You will be able to vote in {18 - age} year(s)")
else:
    print("You are too young to vote")
    print(f"You need to wait {18 - age} more years")

# Output for age = 17:
# You will be able to vote in 1 year(s)

age = 45

if age < 0:
    print("Invalid age!")
elif age <= 12:
    price = 100
    category = "Child"
elif age <= 17:
    price = 200
    category = "Teen"
elif age <= 59:
    price = 300
    category = "Adult"
else:
    price = 150
    category = "Senior"

if age >= 0:
    print(f"Category: {category}")
    print(f"Ticket Price: Rs. {price}")

# Output for age = 45:
# Category: Adult
# Ticket Price: Rs. 300

weight = 70  # kg
height = 1.75  # meters

bmi = weight / (height ** 2)

print(f"Your BMI: {bmi:.1f}")

if bmi < 18.5:
    category = "Underweight"
    advice = "Consider consulting a nutritionist for a healthy weight gain plan."
elif bmi < 25:
    category = "Normal weight"
    advice = "Great job! Maintain your healthy lifestyle."
elif bmi < 30:
    category = "Overweight"
    advice = "Consider increasing physical activity and reviewing your diet."
else:
    category = "Obese"
    advice = "Please consult a healthcare provider for personalized guidance."

print(f"Category: {category}")
print(f"Advice: {advice}")

# Output for weight=70, height=1.75:
# Your BMI: 22.9
# Category: Normal weight
# Advice: Great job! Maintain your healthy lifestyle.

Comparison Operators

Comparison operators are symbols used to compare two values. They ask simple yes-or-no questions about your data, and Python answers with True or False.

# Assignment vs Comparison - know the difference!
x = 5       # Assignment: x now holds the value 5
x == 5      # Comparison: checks if x equals 5, returns True
x == 10     # Comparison: checks if x equals 10, returns False

# Common mistake in conditionals:
# if x = 5:   # WRONG! This is assignment, causes SyntaxError
if x == 5:    # CORRECT! This is comparison
    print("x is five")

The single equals = stores a value in a variable, while double equals == compares two values and returns True or False.

# Comparison operators in action
x = 10
y = 5

print(f"x = {x}, y = {y}")
print(f"x == y: {x == y}")   # False (10 is not equal to 5)
print(f"x != y: {x != y}")   # True (10 is not equal to 5)
print(f"x > y: {x > y}")     # True (10 is greater than 5)
print(f"x < y: {x < y}")     # False (10 is not less than 5)
print(f"x >= y: {x >= y}")   # True (10 is greater than or equal to 5)
print(f"x <= y: {x <= y}")   # False (10 is not less than or equal to 5)

Each comparison returns a boolean value (True or False) that can be used directly in conditionals or stored in variables.

Comparing Strings

# String comparison
print("apple" == "apple")    # True (exact match)
print("apple" == "Apple")    # False (case-sensitive!)
print("apple" < "banana")    # True (a comes before b)
print("Apple" < "apple")     # True (uppercase A has lower Unicode value)

# Common use case: case-insensitive comparison
name1 = "Alice"
name2 = "alice"
print(name1.lower() == name2.lower())  # True (convert both to lowercase first)

To compare strings without worrying about case, use .lower() or .upper() to convert both strings to the same case before comparing.

Logical Operators

Logical operators combine multiple conditions into one. Python has three logical operators:

# Logical operators
age = 25
has_license = True
has_insurance = False

We create three variables to represent a person's profile. age stores a number (25), while has_license and has_insurance store boolean values (True/False). These will be used to demonstrate how logical operators work.

# and: both conditions must be True
can_rent_car = age >= 21 and has_license
print(f"Can rent car: {can_rent_car}")  # True (25 >= 21 AND has license)

The and operator requires BOTH conditions to be True. Here we check if age is at least 21 (True, because 25 >= 21) AND if the person has a license (True). Since both are True, can_rent_car becomes True.

# or: at least one condition must be True
needs_attention = age < 18 or age > 65
print(f"Needs attention: {needs_attention}")  # False (neither condition is True)

The or operator requires AT LEAST ONE condition to be True. We check if age is under 18 (False) OR over 65 (False). Since both are False, needs_attention is False. If either condition were True, the result would be True.

# not: inverts the boolean value
is_uninsured = not has_insurance
print(f"Is uninsured: {is_uninsured}")  # True (not False = True)

The not operator flips a boolean value. Since has_insurance is False, not has_insurance becomes True. This is useful when you want to check the opposite of a condition.

# Combining multiple operators
is_eligible = (age >= 21) and has_license and (not has_insurance)
print(f"Eligible for special offer: {is_eligible}")  # True

You can combine multiple logical operators in one expression. This checks three things: age >= 21 (True), has_license (True), and not has_insurance (True). Since all three are True, the result is True. Parentheses make the expression easier to read.

# Safe division using short-circuit evaluation
x = 10
y = 0

# The second condition only runs if y != 0
if y != 0 and x / y > 5:
    print("Result is greater than 5")

# Without short-circuit, x / y would cause ZeroDivisionError!

Short-circuit evaluation is useful for safety checks — the division only happens if y is not zero.

Chained Comparisons

# Verbose and repetitive
if score >= 70 and score < 80:
    grade = "C"

# Check if x is between 1 and 10
if x > 1 and x < 10:
    print("In range")

# Clean and mathematical
if 70 <= score < 80:
    grade = "C"

# Check if x is between 1 and 10
if 1 < x < 10:
    print("In range")

# Chained comparisons - Python allows this!
score = 75

# Instead of: score >= 70 and score < 80
if 70 <= score < 80:
    print("Grade: C")

# Multiple chained comparisons
x = 5
print(1 < x < 10)     # True (x is between 1 and 10)
print(1 < x < 3)      # False (x is not between 1 and 3)
print(0 < x == 5)     # True (x > 0 AND x equals 5)

# Real-world example: time validation
hour = 14
if 9 <= hour < 17:
    print("Business hours")  # This prints for hour = 14
else:
    print("Closed")

Chained comparisons make range checks intuitive. 70 <= score < 80 reads as "score is at least 70 and less than 80."

Identity and Membership Operators

# Identity operators (check if same object in memory)
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)       # True (same values)
print(a is b)       # False (different objects in memory)
print(a is c)       # True (c points to same object as a)

# None should always be checked with 'is'
result = None
if result is None:
    print("No result yet")

The is operator is mainly used for checking None. For most comparisons, use ==.

# Membership operators
fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)     # True
print("mango" not in fruits)  # True

# Works with strings too
message = "Hello, World!"
if "World" in message:
    print("Found 'World' in the message")

# Check dictionary keys
user = {"name": "Alice", "age": 25}
if "email" not in user:
    print("Email not provided")  # This prints

# Useful for input validation
valid_choices = ["yes", "no", "maybe"]
user_input = "yes"
if user_input.lower() in valid_choices:
    print(f"Valid choice: {user_input}")

The in operator is perfect for checking if user input is valid, if a key exists in a dictionary, or if a substring is in a larger string.

score = 85

if 0 <= score <= 100:
    print(f"Valid score: {score}%")
else:
    print(f"Invalid score: {score}. Must be between 0-100")

# Output: Valid score: 85%

# Test with invalid score
score = 150
if 0 <= score <= 100:
    print(f"Valid score: {score}%")
else:
    print(f"Invalid score: {score}. Must be between 0-100")

# Output: Invalid score: 150. Must be between 0-100

username = "alice"
password = "securePass123"

# Individual checks
valid_username = len(username) >= 4
valid_password = len(password) >= 8
not_same = username.lower() != password.lower()

# Combined validation
if valid_username and valid_password and not_same:
    print("Login credentials are valid!")
else:
    print("Invalid credentials:")
    if not valid_username:
        print("- Username must be at least 4 characters")
    if not valid_password:
        print("- Password must be at least 8 characters")
    if not not_same:
        print("- Username and password cannot be the same")

# Output: Login credentials are valid!

user_role = "manager"
requested_resource = "reports"
user_id = "user123"
resource_owner = "user456"

# Define access permissions
admin_resources = ["settings", "users", "reports", "logs", "database"]
manager_resources = ["users", "reports"]
user_resources = ["own_profile", "own_data"]

def check_access(role, resource, user_id, owner_id):
    # Admins can access everything
    if role == "admin":
        return True
    
    # Managers can access specific resources
    if role == "manager" and resource in manager_resources:
        return True
    
    # Users can only access their own data
    if role == "user":
        is_own_resource = resource in user_resources
        is_owner = user_id == owner_id
        if is_own_resource or is_owner:
            return True
    
    return False

# Test access
has_access = check_access(user_role, requested_resource, user_id, resource_owner)
print(f"Role: {user_role}")
print(f"Requesting: {requested_resource}")
print(f"Access granted: {has_access}")

# Output:
# Role: manager
# Requesting: reports
# Access granted: True

Basic Nested Structure

# Nested conditional example - ATM withdrawal
has_card = True
correct_pin = True
balance = 5000
withdrawal_amount = 3000

We set up four variables to simulate an ATM transaction: a card is inserted, the PIN is correct, the account has Rs. 5000, and the user wants to withdraw Rs. 3000.

if has_card:
    print("Card detected")

The outermost if checks if a card is inserted. Only when this is True do we proceed to check anything else. This is the first "gate" in our security chain.

    if correct_pin:
        print("PIN verified")

Inside the first if, we check the PIN. This is a nested if - it only runs if the card check passed. Notice the extra indentation showing it's inside the first block.

        if withdrawal_amount <= balance:
            balance -= withdrawal_amount
            print(f"Dispensing Rs. {withdrawal_amount}")
            print(f"New balance: Rs. {balance}")

The deepest nested if checks if there's enough money. If all three conditions pass, we subtract the amount from the balance and dispense the cash. This is the "happy path" - everything went right!

        else:
            print("Insufficient funds!")
    else:
        print("Incorrect PIN!")
else:
    print("Please insert card")

Each else handles the failure case at its level. The error messages are specific to which check failed: no card, wrong PIN, or not enough money. The indentation matches the if it belongs to.

Each level of nesting depends on the previous check passing. It would not make sense to check the balance before verifying the PIN, or to dispense money before checking the balance. This dependency chain is what makes nested conditionals appropriate here.

Flattening Nested Conditions

Compare these two approaches - they do the exact same thing, but one is much easier to read:

# Deep nesting (harder to read)
def process_order_nested(order):

We define a function called process_order_nested that takes an order dictionary as input. This function needs to verify several things before processing the order: the order must exist, have a pending status, contain items, and have verified payment. The nested approach checks these conditions by going deeper and deeper into indentation levels.

    if order is not None:

First level of nesting: We check if the order object actually exists (is not None). If someone calls this function without an order, we don't want the code to crash. Notice that ALL the remaining logic will be indented inside this check — if the order is None, we skip everything and fall through to the final return False.

        if order["status"] == "pending":

Second level of nesting: Inside the first check, we verify the order status is "pending". Orders that are already "shipped", "cancelled", or "completed" shouldn't be processed again. Notice we're now 2 indentation levels deep (8 spaces). The code is starting to drift rightward — this is the beginning of the "pyramid" shape.

            if order["items"]:

Third level of nesting: We check if the order actually contains any items. An empty list [] is "falsy" in Python, so if order["items"]: returns False for empty orders. We're now 3 indentation levels deep (12 spaces). The code is visibly forming a pyramid shape, making it harder to track which if each else would belong to.

                if order["payment_verified"]:
                    print("Processing order...")
                    return True
    return False

Fourth level of nesting: Finally, at 4 levels deep (16 spaces of indentation!), we check if payment was verified. Only after passing ALL four nested checks do we actually process the order and return True. The lonely return False at the bottom catches ANY failure from ANY level — but which check failed? We have no idea without debugging. This "pyramid of doom" is confusing, error-prone, and difficult to maintain.

# Flattened version using early returns (cleaner!)
def process_order_flat(order):

This is the exact same logic, rewritten using the guard clause pattern. The key idea: instead of nesting successful cases, we check for failure cases and exit immediately using return. This eliminates nesting entirely! Each check is independent, and the code stays flat at one indentation level.

    if order is None:
        return False

Guard clause 1: If the order doesn't exist, we immediately return False and exit the function. The key difference from nesting: we check for the failure condition (is None) instead of the success condition (is not None). Once this check passes, we KNOW the order exists for all remaining code — we can mentally "forget" about this possibility.

    if order["status"] != "pending":
        return False

Guard clause 2: If the status is NOT pending, exit immediately. Notice the logic is inverted: we use != instead of ==. We're asking "is this condition BAD?" instead of "is this condition good?". If the status is wrong, we bail out. If we get past this line, we KNOW the status is pending — no need to track nested state.

    if not order["items"]:
        return False

Guard clause 3: If there are no items in the order (empty list), exit. The not keyword inverts the truthiness check. Each guard clause reads like a simple rule: "If X is wrong, stop." There's no hunting through nested braces to understand the logic. By this point, we KNOW: order exists, status is pending, and there are items.

    if not order["payment_verified"]:
        return False

Guard clause 4: The final check — if payment isn't verified, exit. We've now handled ALL possible failure cases at the same indentation level. Each guard clause is like a bouncer at a club: "No ID? You're out. Wrong dress code? You're out." Only the valid cases make it through the gauntlet to the next line.

    print("Processing order...")
    return True

The "happy path"! If the code reaches this point, we know for certain: the order exists, status is pending, there are items, and payment is verified. All four guards passed! The main business logic sits at the end, completely unindented from any conditional blocks. This is the beauty of guard clauses — the important code is easy to find, and you don't need to mentally track multiple nested conditions to understand when it runs.

When to Use Nested vs Flat

Use nested conditionals when the logic truly requires hierarchical decision-making. Use flat conditionals with logical operators when you are just checking multiple requirements for the same outcome.

# Using logical operators instead of nesting
age = 25
has_license = True
has_insurance = True

# Nested (unnecessary complexity)
if age >= 18:
    if has_license:
        if has_insurance:
            print("You can drive")

# Flattened with 'and' (better!)
if age >= 18 and has_license and has_insurance:
    print("You can drive")

# With meaningful variable for even better readability
meets_driving_requirements = age >= 18 and has_license and has_insurance
if meets_driving_requirements:
    print("You can drive")

is_international = False
weight = 1.5  # kg
is_express = True

# Calculate base shipping cost
if is_international:
    if weight < 2:
        base_cost = 50 * 3  # 150
    else:
        base_cost = 100 * 3  # 300
else:  # domestic
    if weight < 2:
        base_cost = 50
    else:
        base_cost = 100

# Apply express multiplier
if is_express:
    final_cost = base_cost * 2
else:
    final_cost = base_cost

# Output
shipping_type = "International" if is_international else "Domestic"
weight_cat = "Heavy" if weight >= 2 else "Light"
speed = "Express" if is_express else "Standard"

print(f"Shipping: {shipping_type} {speed} ({weight_cat})")
print(f"Cost: Rs. {final_cost}")

# Output:
# Shipping: Domestic Express (Light)
# Cost: Rs. 100

# Original nested code
def validate_user(user):
    if user is not None:
        if user.get("active"):
            if user.get("email"):
                if "@" in user["email"]:
                    if user.get("age", 0) >= 18:
                        return "User is valid"
    return "User is invalid"

def validate_user(user):
    """Validate user with guard clauses - much cleaner!"""
    
    # Guard clause: check if user exists
    if user is None:
        return "User is invalid: No user provided"
    
    # Guard clause: check if user is active
    if not user.get("active"):
        return "User is invalid: Account not active"
    
    # Guard clause: check if email exists
    email = user.get("email")
    if not email:
        return "User is invalid: No email provided"
    
    # Guard clause: check email format
    if "@" not in email:
        return "User is invalid: Invalid email format"
    
    # Guard clause: check age
    if user.get("age", 0) < 18:
        return "User is invalid: Must be 18 or older"
    
    # All checks passed!
    return "User is valid"

# Test the refactored function
test_user = {
    "active": True,
    "email": "alice@example.com",
    "age": 25
}
print(validate_user(test_user))  # User is valid

invalid_user = {"active": True, "email": "no-at-sign"}
print(validate_user(invalid_user))  # User is invalid: Invalid email format

Basic Syntax

Let us compare a regular if-else with its ternary equivalent:

# Traditional if-else
age = 20
if age >= 18:
    status = "adult"
else:
    status = "minor"

# Same thing with ternary operator (one line!)
status = "adult" if age >= 18 else "minor"
print(status)  # adult

# Using ternary in print statements
score = 85
print(f"Result: {'Pass' if score >= 40 else 'Fail'}")  # Result: Pass

# Assigning different values
temperature = 35
message = "Hot day!" if temperature > 30 else "Pleasant weather"
print(message)  # Hot day!

Common Use Cases

The ternary operator shines in situations where you need to quickly choose between two values. It keeps your code concise without sacrificing clarity.

# Use case 1: Setting default values
user_name = ""
display_name = user_name if user_name else "Guest"
print(f"Welcome, {display_name}")  # Welcome, Guest

# Use case 2: Pluralization
item_count = 5
message = f"You have {item_count} item{'s' if item_count != 1 else ''}"
print(message)  # You have 5 items

# Use case 3: Formatting output
balance = -500
formatted = f"Rs. {balance}" if balance >= 0 else f"Rs. ({abs(balance)})"
print(formatted)  # Rs. (500)

# Use case 4: Boolean conversion with meaning
is_active = True
status_text = "Active" if is_active else "Inactive"
print(status_text)  # Active

Chained Ternary (Use Sparingly!)

# Chained ternary (can be hard to read)
score = 75

We set a test score of 75. We want to convert this number into a letter grade (A, B, C, D, or F).

grade = "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "D" if score >= 60 else "F"
print(grade)  # C

This is a chained ternary - multiple ternary operators connected together. It checks: if score >= 90 return "A", else if score >= 80 return "B", else if score >= 70 return "C", and so on. Since 75 >= 70, it returns "C". But notice how hard this is to read!

# The same logic is clearer as if-elif-else
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

This is the exact same logic written as if-elif-else. It does the same thing but is MUCH easier to read and understand. Each condition is on its own line, and the structure is clear.

# Better alternative: use a function for complex logic
def get_grade(score):
    if score >= 90: return "A"
    if score >= 80: return "B"
    if score >= 70: return "C"
    if score >= 60: return "D"
    return "F"

grade = get_grade(75)  # C

Even better: put the logic in a function! This uses early returns (each return exits the function immediately). The function is reusable and the code is clean. This is what experienced programmers prefer.

number = 7
if number % 2 == 0:
    parity = "even"
else:
    parity = "odd"

number = 7
parity = "even" if number % 2 == 0 else "odd"
print(f"{number} is {parity}")  # 7 is odd

total = 750

# Determine discount percentage using chained ternary
discount_percent = 20 if total >= 1000 else 10 if total >= 500 else 0

# Calculate discount amount and final price
discount_amount = total * (discount_percent / 100)
final_price = total - discount_amount

print(f"Original: Rs. {total}")
print(f"Discount: {discount_percent}% (Rs. {discount_amount})")
print(f"Final Price: Rs. {final_price}")

# Output:
# Original: Rs. 750
# Discount: 10% (Rs. 75.0)
# Final Price: Rs. 675.0

Basic Match-Case Syntax

Here is a simple example that checks what day of the week it is:

# Basic match-case (Python 3.10+)
def get_day_type(day):

We define a function that takes a day name as a string. This function will categorize days into different types like "Weekend", "Work day", etc.

    match day.lower():

The match keyword starts the pattern matching. We call .lower() to convert the input to lowercase, so "Saturday", "SATURDAY", and "saturday" all work the same way.

        case "saturday" | "sunday":
            return "Weekend - Time to relax!"

The pipe symbol | means "OR" — this case matches if the day is "saturday" OR "sunday". Both weekend days share the same response. This is cleaner than writing two separate cases!

        case "monday":
            return "Start of the work week"

A simple exact match — if the day is exactly "monday", return this specific message. Monday gets its own special (dreaded?) message.

        case "friday":
            return "TGIF! Almost weekend!"

Another exact match for Friday. TGIF = "Thank God It's Friday!" — Friday also deserves its own celebration message.

        case "tuesday" | "wednesday" | "thursday":
            return "Regular work day"

Multiple values with | again — Tuesday, Wednesday, and Thursday are all "regular" work days, so they share one response. Much cleaner than three separate if statements!

        case _:
            return "Invalid day"

The wildcard pattern _ matches ANYTHING not caught by previous cases. This is your "default" or "else" case. If someone passes "xyz" or "banana", this catches it.

print(get_day_type("Saturday"))  # Weekend - Time to relax!
print(get_day_type("Monday"))    # Start of the work week
print(get_day_type("xyz"))       # Invalid day

Testing our function: "Saturday" matches the weekend case (converted to lowercase first), "Monday" matches its exact case, and "xyz" falls through to the wildcard default.

Pattern Matching with Values

Here is where match-case gets really useful! You can add extra conditions (called "guards") using the if keyword. This lets you match ranges of values instead of listing every single one.

For example, instead of writing case 200: case 201: case 202: ... for all successful HTTP codes, you can write case code if 200 <= code < 300: to match ANY number in that range!

# Matching HTTP status codes
def describe_http_status(code):

We define a function that takes an HTTP status code (a number like 200, 404, 500) and returns a human-readable description. This is a perfect use case for match-case!

    match code:

We start matching against the code parameter. Python will check each case pattern from top to bottom until it finds one that matches.

        case 200:
            return "OK - Request successful"
        case 201:
            return "Created - Resource created"
        case 400:
            return "Bad Request - Invalid syntax"
        case 401:
            return "Unauthorized - Authentication required"
        case 403:
            return "Forbidden - Access denied"
        case 404:
            return "Not Found - Resource does not exist"
        case 500:
            return "Internal Server Error"

These are literal matches — exact values we want to handle specifically. The most common HTTP codes get their own descriptive messages. Since these are checked first, they'll match before the range patterns below.

        case code if 200 <= code < 300:
            return f"Success ({code})"

This is a guard pattern! The case code part captures the value into a variable called code, and the if 200 <= code < 300 part adds an extra condition. This matches ANY success code (200-299) that wasn't caught by the specific cases above.

        case code if 400 <= code < 500:
            return f"Client Error ({code})"
        case code if 500 <= code < 600:
            return f"Server Error ({code})"

More guard patterns for client errors (400-499) and server errors (500-599). Instead of listing every possible code, we handle entire ranges with a single case each. The captured code variable lets us include the actual number in the message.

        case _:
            return f"Unknown status: {code}"

The wildcard pattern _ catches anything not matched above. This acts as our default case for unusual status codes like 600+ or negative numbers.

print(describe_http_status(200))  # OK - Request successful
print(describe_http_status(204))  # Success (204)
print(describe_http_status(418))  # Client Error (418)

Testing our function: 200 matches the specific case, 204 matches the 200-299 range pattern (since there's no specific case for it), and 418 (the famous "I'm a teapot" code!) matches the 400-499 range.

Matching Sequences and Structures

# Matching tuple structures - coordinate processing
def describe_point(point):

We define a function that takes a point (a tuple like (3, 5)) and returns a description of where it is on a coordinate plane. This is a classic use case for destructuring patterns!

    match point:

We start matching against the point tuple. Python will check each case pattern to see if the shape and values match.

        case (0, 0):
            return "Origin"

Exact match: This only matches the specific tuple (0, 0) — the origin point where both coordinates are zero. No variables are captured; we're matching literal values.

        case (0, y):
            return f"On Y-axis at y={y}"

Partial match with capture: This matches any tuple where the first element is exactly 0, and captures the second element into variable y. Points like (0, 5) or (0, -3) would match, and we can use y in our response!

        case (x, 0):
            return f"On X-axis at x={x}"

Another partial match: This matches any tuple where the second element is 0, capturing the first element as x. Points like (3, 0) or (-7, 0) lie on the X-axis.

        case (x, y) if x == y:
            return f"On diagonal at ({x}, {y})"

Pattern + Guard: This matches any 2-tuple AND captures both values, BUT the guard if x == y adds an extra condition — it only matches if both coordinates are equal. Points like (4, 4) or (7, 7) lie on the diagonal line.

        case (x, y):
            return f"Point at ({x}, {y})"

General capture: This matches ANY 2-tuple and captures both values. It's the "catch-all" for valid points that didn't match more specific patterns above. This must come AFTER more specific cases!

        case _:
            return "Not a valid point"

Wildcard: If the input isn't a 2-tuple at all (like a string, a 3-tuple, or None), this catches it and returns an error message.

print(describe_point((0, 0)))     # Origin
print(describe_point((0, 5)))     # On Y-axis at y=5
print(describe_point((3, 0)))     # On X-axis at x=3
print(describe_point((4, 4)))     # On diagonal at (4, 4)
print(describe_point((2, 7)))     # Point at (2, 7)

Testing all the different cases: origin matches exact (0, 0), (0, 5) matches Y-axis pattern, (3, 0) matches X-axis pattern, (4, 4) matches diagonal guard, and (2, 7) falls through to the general capture.

Matching with Guards

Guards (using if) add additional conditions to patterns. The pattern only matches if both the structure matches AND the guard condition is true.

Guards are essential when you need to match based on criteria that cannot be expressed with patterns alone. For example, you cannot write a pattern that matches "any number greater than 50" - you need a guard for that. Guards give you the full power of Python expressions to add conditions to your patterns.

The guard condition is evaluated only if the pattern matches. This means you can safely use variables captured by the pattern in the guard condition:

# Using guards for additional conditions
def categorize_score(score):
    match score:
        case n if n < 0 or n > 100:
            return "Invalid score"
        case n if n >= 90:
            return "A - Excellent"
        case n if n >= 80:
            return "B - Good"
        case n if n >= 70:
            return "C - Average"
        case n if n >= 60:
            return "D - Below Average"
        case _:
            return "F - Fail"

print(categorize_score(95))   # A - Excellent
print(categorize_score(75))   # C - Average
print(categorize_score(-5))   # Invalid score

def process_command(command):
    parts = command.lower().split()
    
    match parts:
        case ["quit"] | ["exit"]:
            return "Exiting program..."
        case ["help"]:
            return "Available commands: quit, help, save , load "
        case ["save", filename]:
            return f"Saving to {filename}..."
        case ["load", filename]:
            return f"Loading from {filename}..."
        case ["save"] | ["load"]:
            return "Error: Please specify a filename"
        case []:
            return "No command entered"
        case _:
            return f"Unknown command: {' '.join(parts)}"

# Test the command processor
print(process_command("help"))           # Available commands: ...
print(process_command("save data.txt"))  # Saving to data.txt...
print(process_command("load"))           # Error: Please specify a filename
print(process_command("foo bar"))        # Unknown command: foo bar

def calculate(expression):
    match expression:
        case (a, "+", b):
            return a + b
        case (a, "-", b):
            return a - b
        case (a, "*", b):
            return a * b
        case (a, "/", b) if b != 0:
            return a / b
        case (a, "/", 0):
            return "Error: Division by zero"
        case (a, "**", b):
            return a ** b
        case (a, "%", b) if b != 0:
            return a % b
        case (_, op, _) if op not in ["+", "-", "*", "/", "**", "%"]:
            return f"Error: Unknown operator '{op}'"
        case _:
            return "Error: Invalid expression format"

# Test the calculator
print(calculate((10, "+", 5)))    # 15
print(calculate((10, "-", 3)))    # 7
print(calculate((4, "*", 7)))     # 28
print(calculate((20, "/", 4)))    # 5.0
print(calculate((10, "/", 0)))    # Error: Division by zero
print(calculate((2, "**", 8)))    # 256
print(calculate((10, "&", 5)))    # Error: Unknown operator '&'