Nested Conditionals and Loops in Python

Nested Conditionals

A nested conditional is simply an if, elif, or else statement that contains another conditional statement within its block. This creates a hierarchy of decisions, where the inner decision is only considered when the outer condition is met.

Basic Structure

if outer_condition:
    # Outer condition is True
    if inner_condition:
        # Both outer and inner conditions are True
        perform_action_a()
    else:
        # Outer condition is True, but inner condition is False
        perform_action_b()
else:
    # Outer condition is False
    perform_action_c()

This pattern creates a decision tree with different execution paths. Let's look at some practical examples.

Example: Loan Approval System

def evaluate_loan_application(credit_score, income, loan_amount):
    """
    Evaluate a loan application based on multiple criteria.
    Returns a tuple of (approved, reason).
    """
    if credit_score >= 700:  # First level: Good credit
        if income >= 50000:  # Second level: Sufficient income
            if loan_amount <= income * 0.3:  # Third level: Reasonable loan amount
                return True, "Loan approved based on excellent criteria"
            else:
                return False, "Loan amount exceeds 30% of income"
        else:
            if loan_amount <= income * 0.15:  # Low income but very small loan
                return True, "Loan approved with limited amount"
            else:
                return False, "Insufficient income for requested loan amount"
    else:  # Lower credit score
        if credit_score >= 600:  # Medium credit
            if income >= 70000 and loan_amount <= income * 0.15:
                return True, "Loan approved with conditions"
            else:
                return False, "Credit score and income/loan ratio not sufficient"
        else:  # Poor credit
            return False, "Credit score below minimum threshold"

# Test with various scenarios
test_cases = [
    (750, 60000, 15000),  # Good credit, good income, reasonable loan
    (750, 60000, 30000),  # Good credit, good income, high loan
    (750, 40000, 5000),   # Good credit, lower income, small loan
    (650, 75000, 10000),  # Medium credit, good income, small loan
    (650, 50000, 10000),  # Medium credit, medium income, medium loan
    (550, 90000, 10000)   # Poor credit, excellent income, small loan
]

for case in test_cases:
    credit, income, loan = case
    approved, reason = evaluate_loan_application(credit, income, loan)
    
    print(f"Credit: {credit}, Income: ${income}, Loan: ${loan}")
    print(f"Decision: {'APPROVED' if approved else 'DENIED'}")
    print(f"Reason: {reason}")
    print("-" * 50)

This loan approval system demonstrates nested conditionals with three levels of decision-making. The decision tree branches based on credit score, income, and loan amount, creating a sophisticated approval process that reflects real-world financial decision-making.

Example: Weather Activity Recommender

def recommend_activity(temperature, precipitation, wind_speed):
    """
    Recommend an activity based on weather conditions.
    """
    if precipitation == "none":  # No precipitation
        if temperature > 80:  # Hot weather
            if wind_speed < 10:  # Low wind
                return "Go swimming"
            else:  # Windy
                return "Go sailing"
        elif temperature > 60:  # Warm weather
            if wind_speed < 15:  # Low to moderate wind
                return "Go hiking"
            else:  # Windy
                return "Go flying a kite"
        else:  # Cool weather
            return "Go for a scenic drive"
    elif precipitation == "rain":  # Rainy
        if temperature > 70:  # Warm rain
            return "Visit a museum"
        else:  # Cold rain
            return "Stay home and read a book"
    elif precipitation == "snow":  # Snowy
        if temperature > 25:  # Not too cold
            return "Go sledding"
        else:  # Very cold
            return "Build a snowman"
    else:  # Other conditions (fog, hail, etc.)
        return "Indoor activities recommended"

# Test with various weather conditions
weather_conditions = [
    (85, "none", 5),     # Hot, clear, calm
    (85, "none", 20),    # Hot, clear, windy
    (65, "none", 10),    # Warm, clear, light wind
    (65, "none", 25),    # Warm, clear, windy
    (45, "none", 5),     # Cool, clear, calm
    (75, "rain", 5),     # Warm, rainy, calm
    (55, "rain", 15),    # Cool, rainy, windy
    (30, "snow", 10),    # Cold, snowy, light wind
    (15, "snow", 5),     # Very cold, snowy, calm
    (65, "fog", 5)       # Warm, foggy, calm
]

for condition in weather_conditions:
    temp, precip, wind = condition
    activity = recommend_activity(temp, precip, wind)
    
    print(f"Weather: {temp}°F, {precip}, {wind} mph wind")
    print(f"Recommended activity: {activity}")
    print("-" * 50)

This activity recommender demonstrates how nested conditionals can model a decision process with multiple factors. The outer condition checks precipitation, while inner conditions evaluate temperature and wind speed, resulting in activity recommendations tailored to specific weather combinations.

Flattening Nested Conditionals

While nested conditionals are sometimes necessary, deeply nested structures can lead to "the pyramid of doom" or "arrow code"—code that indents so far right that it becomes difficult to read and maintain. Here are techniques to flatten nested conditionals:

Using Compound Conditions

# Nested approach
def check_eligibility_nested(age, citizenship, residence_years):
    if age >= 18:
        if citizenship == "yes":
            if residence_years >= 5:
                return "Eligible"
            else:
                return "Not eligible: insufficient residence years"
        else:
            return "Not eligible: not a citizen"
    else:
        return "Not eligible: under 18"

# Flattened with compound conditions
def check_eligibility_flat(age, citizenship, residence_years):
    if age < 18:
        return "Not eligible: under 18"
    if citizenship != "yes":
        return "Not eligible: not a citizen"
    if residence_years < 5:
        return "Not eligible: insufficient residence years"
    
    return "Eligible"

The flattened version is more readable and avoids the deep nesting. This approach uses early returns for failure cases, which is a common pattern in programming.

Using Logical Operators

# Nested approach
def check_order_nested(stock, credit, shipping):
    if stock > 0:
        if credit > 100:
            if shipping == "available":
                return "Order processed"
            else:
                return "No shipping available"
        else:
            return "Insufficient credit"
    else:
        return "Out of stock"

# Flattened with logical operators
def check_order_flat(stock, credit, shipping):
    if stock <= 0:
        return "Out of stock"
    if credit <= 100:
        return "Insufficient credit"
    if shipping != "available":
        return "No shipping available"
    
    return "Order processed"

# Alternative using a single compound condition
def check_order_compound(stock, credit, shipping):
    if stock > 0 and credit > 100 and shipping == "available":
        return "Order processed"
    else:
        # Determine the specific reason
        if stock <= 0:
            return "Out of stock"
        if credit <= 100:
            return "Insufficient credit"
        return "No shipping available"

Both flattened versions eliminate the deep nesting, making the code more maintainable. The first approach uses early returns for failure cases, while the second uses a compound condition for the success case. Either approach is valid, but early returns often lead to cleaner code.

Real-World Example: E-commerce Order Processing

def process_order(order):
    """
    Process an e-commerce order through a series of validation
    and fulfillment steps.
    """
    # Extract order details
    customer_id = order.get("customer_id")
    items = order.get("items", [])
    payment_method = order.get("payment_method")
    shipping_address = order.get("shipping_address")
    promo_code = order.get("promo_code")
    
    # Validate customer
    if not customer_id:
        return {"status": "error", "message": "Customer ID is required"}
    
    customer = get_customer(customer_id)
    if not customer:
        return {"status": "error", "message": "Customer not found"}
    
    if customer["status"] == "blocked":
        return {"status": "error", "message": "Customer account is blocked"}
    
    # Validate items
    if not items:
        return {"status": "error", "message": "No items in order"}
    
    # Check inventory and calculate total
    order_total = 0
    unavailable_items = []
    
    for item in items:
        product_id = item.get("product_id")
        quantity = item.get("quantity", 1)
        
        product = get_product(product_id)
        if not product:
            unavailable_items.append(f"Product {product_id} not found")
            continue
        
        if product["inventory"] < quantity:
            unavailable_items.append(f"Insufficient inventory for {product['name']}")
            continue
        
        item_price = product["price"] * quantity
        order_total += item_price
    
    if unavailable_items:
        return {
            "status": "error", 
            "message": "Some items are unavailable",
            "details": unavailable_items
        }
    
    # Apply promotion if valid
    if promo_code:
        promo = get_promotion(promo_code)
        if promo and promo["active"]:
            if promo["min_purchase"] <= order_total:
                if promo["type"] == "percentage":
                    discount = order_total * (promo["value"] / 100)
                else:  # Fixed amount
                    discount = promo["value"]
                
                order_total -= discount
            else:
                return {
                    "status": "error",
                    "message": f"Order total does not meet minimum for promo code {promo_code}"
                }
        else:
            return {"status": "error", "message": "Invalid or expired promo code"}
    
    # Validate payment method
    if not payment_method:
        return {"status": "error", "message": "Payment method is required"}
    
    if payment_method["type"] == "credit_card":
        if payment_method.get("expired", False):
            return {"status": "error", "message": "Credit card is expired"}
        
        if not validate_credit_card(payment_method):
            return {"status": "error", "message": "Invalid credit card information"}
    elif payment_method["type"] == "paypal":
        if not validate_paypal(payment_method):
            return {"status": "error", "message": "Invalid PayPal account"}
    else:
        return {"status": "error", "message": "Unsupported payment method"}
    
    # Validate shipping address
    if not shipping_address:
        return {"status": "error", "message": "Shipping address is required"}
    
    if not shipping_address.get("country") or not shipping_address.get("zip_code"):
        return {"status": "error", "message": "Incomplete shipping address"}
    
    # Check if we ship to the customer's country
    if shipping_address["country"] not in get_supported_countries():
        return {"status": "error", "message": f"We don't ship to {shipping_address['country']}"}
    
    # All validations passed, process the order
    return {
        "status": "success",
        "message": "Order processed successfully",
        "order_id": generate_order_id(),
        "total": order_total,
        "estimated_delivery": calculate_delivery_date(shipping_address)
    }

# Simulate the helper functions
def get_customer(customer_id):
    # In a real system, this would query a database
    customers = {
        "C001": {"name": "Alice Smith", "status": "active"},
        "C002": {"name": "Bob Jones", "status": "blocked"},
    }
    return customers.get(customer_id)

def get_product(product_id):
    # In a real system, this would query a database
    products = {
        "P001": {"name": "Laptop", "price": 999.99, "inventory": 5},
        "P002": {"name": "Smartphone", "price": 499.99, "inventory": 10},
        "P003": {"name": "Headphones", "price": 99.99, "inventory": 0},
    }
    return products.get(product_id)

def get_promotion(promo_code):
    # In a real system, this would query a database
    promotions = {
        "SUMMER20": {"active": True, "type": "percentage", "value": 20, "min_purchase": 100},
        "WELCOME10": {"active": False, "type": "percentage", "value": 10, "min_purchase": 50},
        "FREESHIP": {"active": True, "type": "fixed", "value": 15, "min_purchase": 75},
    }
    return promotions.get(promo_code)

def validate_credit_card(payment_info):
    # In a real system, this would call a payment processor API
    return len(payment_info.get("card_number", "")) == 16

def validate_paypal(payment_info):
    # In a real system, this would call PayPal's API
    return "@" in payment_info.get("email", "")

def get_supported_countries():
    return ["USA", "Canada", "UK", "Australia", "Germany", "France", "Japan"]

def generate_order_id():
    import random
    return f"ORD-{random.randint(10000, 99999)}"

def calculate_delivery_date(address):
    import datetime
    # In a real system, this would calculate based on shipping method and distance
    today = datetime.datetime.now()
    delivery_date = today + datetime.timedelta(days=5)
    return delivery_date.strftime("%Y-%m-%d")

# Test with a sample order
sample_order = {
    "customer_id": "C001",
    "items": [
        {"product_id": "P001", "quantity": 1},
        {"product_id": "P002", "quantity": 2}
    ],
    "payment_method": {
        "type": "credit_card",
        "card_number": "1234567890123456",
        "expired": False
    },
    "shipping_address": {
        "street": "123 Main St",
        "city": "Boston",
        "state": "MA",
        "zip_code": "02108",
        "country": "USA"
    },
    "promo_code": "SUMMER20"
}

result = process_order(sample_order)
print("Order Processing Result:")
for key, value in result.items():
    print(f"{key}: {value}")

This e-commerce order processing example demonstrates a real-world approach to nested conditionals. Instead of deeply nested structures, it uses early returns for validation failures, creating a flatter, more maintainable code structure. Each section validates one aspect of the order, returning an error if the validation fails, or continuing to the next validation if it passes.