How to use 'elif' in Python

The elif statement in Python enables multiple conditional branches in your code, extending beyond simple if-else logic. This powerful control flow feature helps create more sophisticated decision trees while maintaining clean, readable code structure.

This guide covers essential techniques, practical tips, and real-world applications for mastering elif statements. All code examples were developed with Claude, an AI assistant built by Anthropic.

Basic usage of elif statement

age = 25
if age < 18:
    print("You are a minor.")
elif age >= 18:
    print("You are an adult.")

You are an adult.

The code demonstrates a fundamental elif statement that evaluates age-based conditions. The elif age >= 18 creates a mutually exclusive branch, ensuring the code only executes one outcome even though both conditions technically overlap at exactly 18.

This example reveals a key principle of elif statements: Python evaluates conditions sequentially and executes only the first matching condition. The remaining conditions won't be checked after a match is found. This behavior makes elif more efficient than multiple separate if statements when handling mutually exclusive scenarios.

Common patterns with elif

Building on these foundational concepts, developers can unlock elif's full potential through sequential conditions, logical operators, and precise value range handling.

Using multiple elif statements in a sequence

score = 85
if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
else:
    print("Grade: D")

Grade: B

This grading system demonstrates how multiple elif statements create a clear hierarchy of conditions. The code evaluates each threshold in descending order, assigning grades based on the first matching condition.

• When score is 85, Python skips the first condition (score >= 90) and matches the second condition (score >= 80). This results in a grade of B.
• The sequential nature ensures accurate grade assignment. A score of 85 technically meets both the B and C thresholds, but the higher grade takes precedence.

The else statement serves as a catch-all for scores below 70, eliminating the need for an explicit condition like score < 70. This pattern creates efficient, maintainable code for handling multiple ranges.

Combining elif with logical operators

temp = 28
if temp < 0:
    print("Freezing")
elif temp < 10:
    print("Cold")
elif 20 <= temp < 30:
    print("Warm")
elif temp >= 30:
    print("Hot")

Warm

This temperature classification system showcases how elif statements can handle complex range comparisons. The code evaluates temperature thresholds in a logical sequence, from coldest to hottest, using comparison operators.

• The chained comparison 20 <= temp < 30 demonstrates Python's elegant syntax for range checks. It's equivalent to writing temp >= 20 and temp < 30 but more concise.
• Notice the intentional gap between temp < 10 and 20 <= temp < 30. This means temperatures from 10-19 won't trigger any output. Such gaps can be useful when you need specific ranges to remain unclassified.

The example outputs "Warm" because 28 falls within the third condition's range. Each condition is mutually exclusive, ensuring clear temperature categorization without overlap.

Using elif with value ranges

age = 35
if 0 <= age < 13:
    print("Child")
elif 13 <= age < 20:
    print("Teenager")
elif 20 <= age < 60:
    print("Adult")
elif age >= 60:
    print("Senior")

Adult

This age classification system demonstrates how to create precise, non-overlapping value ranges with elif statements. The conditions use Python's chained comparison operators to establish clear age boundaries, making the code both readable and efficient.

• The 0 <= age < 13 syntax creates an inclusive range that catches all child ages from 0 to 12.
• Each subsequent condition builds on the previous range's upper limit, ensuring no age falls through the cracks.
• The final condition age >= 60 captures all remaining ages without needing an explicit upper bound.

When the code processes age = 35, it matches the third condition 20 <= age < 60 and outputs "Adult". This approach prevents edge cases and ambiguity in age classification.

Advanced techniques with elif

Building on these foundational patterns, Python's elif statement enables more sophisticated implementations through nested conditions, function integration, and dictionary-based optimizations.

Nested elif structures

weather = "rainy"
temp = 15

if weather == "sunny":
    if temp > 25:
        print("Hot sunny day")
    else:
        print("Pleasant sunny day")
elif weather == "rainy":
    if temp < 10:
        print("Cold rainy day")
    else:
        print("Mild rainy day")

Mild rainy day

Nested elif structures create decision trees that evaluate multiple conditions in sequence. The example demonstrates weather classification that first checks the weather type, then evaluates temperature within each weather category.

• The outer condition (if weather == "sunny" and elif weather == "rainy") determines the primary weather state
• Inner conditions (if temp > 25 and if temp < 10) refine the classification based on temperature thresholds
• This structure produces more specific outputs like "Mild rainy day" instead of just "Rainy"

With weather = "rainy" and temp = 15, Python first matches the elif weather == "rainy" condition. Since 15 isn't less than 10, the code executes the inner else block, outputting "Mild rainy day".

Using elif with functions and methods

def get_day_type(day):
    if day.lower() in ["saturday", "sunday"]:
        return "Weekend"
    elif day.lower() in ["monday", "tuesday", "wednesday", "thursday", "friday"]:
        return "Weekday"
    else:
        return "Invalid day"

print(get_day_type("Sunday"))
print(get_day_type("Monday"))

Weekend
Weekday

The get_day_type() function demonstrates how elif statements can enhance function logic by creating clear decision paths. The function converts any input to lowercase using day.lower(), making the day matching case-insensitive and more user-friendly.

• The first condition checks if the day belongs to a list of weekend days
• The elif condition evaluates weekdays only when the weekend check fails
• The else statement handles invalid inputs, making the function robust against unexpected values

This pattern creates a clean, maintainable way to categorize inputs. The function returns different string values based on the matched condition instead of printing them directly. This approach makes the function more versatile because other parts of your code can use these return values.

Optimizing elif chains with dictionaries

day_number = 3
days = {1: "Monday", 2: "Tuesday", 3: "Wednesday", 4: "Thursday", 5: "Friday"}
print(days.get(day_number, "Weekend"))

status_code = 404
responses = {200: "OK", 404: "Not Found", 500: "Server Error"}
print(responses.get(status_code, "Unknown Status"))

Wednesday
Not Found

Dictionaries offer a more elegant alternative to lengthy elif chains when mapping specific values to outcomes. The get() method efficiently handles lookups while providing a default value for unmatched cases.

• The days dictionary maps numbers to weekdays, returning "Weekend" for any number not between 1-5
• Similarly, the responses dictionary maps HTTP status codes to their descriptions, with "Unknown Status" as the fallback
• This approach reduces code complexity and improves performance compared to multiple elif statements checking each condition

The dictionary solution particularly shines when dealing with many possible conditions. It transforms what could be a dozen lines of elif statements into a clean, maintainable structure that's easier to update and extend.

Using elif for customer support message categorization

The elif statement enables automated customer support systems to efficiently route incoming messages by checking for specific keywords and assigning appropriate support categories.

message = "My order #12345 hasn't arrived yet"
if "password" in message.lower() or "login" in message.lower():
    category = "Account Issues"
elif "order" in message.lower() or "delivery" in message.lower():
    category = "Order Tracking"
elif "refund" in message.lower() or "return" in message.lower():
    category = "Returns & Refunds"
else:
    category = "General Inquiry"
print(f"Support ticket category: {category}")

This code demonstrates an intelligent message categorization system using string pattern matching. The message.lower() method converts the input text to lowercase, ensuring case-insensitive keyword detection. Each condition checks for specific keywords using Python's in operator to determine the appropriate support category.

• The or operator allows multiple related keywords to trigger the same category
• Conditions follow a logical priority order from account issues to general inquiries
• The else statement catches messages that don't match any defined keywords

The final f-string formats the output with the determined category. This approach creates a flexible system that can easily expand to handle new categories by adding more elif conditions.

Building a weather advisory system with elif

The elif statement enables weather advisory systems to deliver personalized recommendations by evaluating both temperature thresholds and weather conditions in a structured decision tree.

def get_weather_advice(temp, condition):
    if temp > 30 and condition == "sunny":
        return "Stay hydrated and use sunscreen"
    elif temp > 30 and condition == "cloudy":
        return "It's hot but clouds provide some relief"
    elif 15 <= temp <= 30 and condition == "rainy":
        return "Take an umbrella with you"
    elif temp < 5:
        return "Dress warmly, it's very cold"
    else:
        return "Weather is moderate, enjoy your day"

print(get_weather_advice(32, "sunny"))

The get_weather_advice function demonstrates effective use of compound conditions to generate weather-specific recommendations. It takes two parameters: temp for temperature and condition for weather status.

• The function evaluates temperature thresholds alongside weather conditions using the and operator to create precise matches
• Temperature checks range from extreme heat (above 30) to very cold (below 5)
• The condition parameter enables contextual advice. For example, a hot day receives different guidance based on whether it's sunny or cloudy

When called with get_weather_advice(32, "sunny"), the function matches the first condition and returns advice about hydration and sun protection. The else statement provides a default response for moderate conditions that don't match specific thresholds.

Common errors and challenges

Even experienced Python developers encounter specific pitfalls when working with elif statements, from condition sequencing to operator confusion.

Incorrect condition order leading to unreachable code with elif

A common mistake with elif statements occurs when developers arrange conditions in a way that makes some branches unreachable. The code below demonstrates how broader conditions can inadvertently block more specific ones from executing.

score = 85
if score >= 70:
    grade = "C"
elif score >= 80:  # This will never execute because the first condition catches it
    grade = "B"
elif score >= 90:  # This will never execute for the same reason
    grade = "A"
print(f"Your grade is {grade}")

The if statement's broad condition score >= 70 captures all scores above 70, preventing higher grades from being assigned. The code below demonstrates the proper sequence for accurate grade assignment.

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "D"
print(f"Your grade is {grade}")

The corrected code arranges conditions from highest to lowest threshold, ensuring each grade range remains accessible. Starting with score >= 90 allows Python to evaluate higher scores first before moving to lower thresholds.

• Always order numerical conditions from most specific to most general
• Watch for overlapping ranges that could prevent code execution
• Consider using comments to document threshold boundaries for clarity

This pattern applies beyond grading systems. Any scenario involving numerical ranges requires careful attention to condition sequencing to prevent logical errors.

Forgetting to handle unexpected inputs with else

Omitting an else clause in conditional statements can lead to unexpected None returns when input falls outside defined conditions. This common oversight affects code reliability and debugging clarity. The following example demonstrates how unhandled inputs create silent failures.

def get_weekday(day_num):
    if day_num == 1:
        return "Monday"
    elif day_num == 2:
        return "Tuesday"
    elif day_num == 3:
        return "Wednesday"

print(get_weekday(9))  # Returns None

The get_weekday() function silently returns None for any input outside 1-3. This creates debugging challenges since the code continues running without error messages. The solution appears in the following example.

def get_weekday(day_num):
    if day_num == 1:
        return "Monday"
    elif day_num == 2:
        return "Tuesday"
    elif day_num == 3:
        return "Wednesday"
    else:
        return "Invalid day number"

print(get_weekday(9))  # Returns "Invalid day number"

Adding an else clause to handle invalid inputs prevents silent failures and improves code reliability. The updated get_weekday() function returns "Invalid day number" instead of None when the input falls outside the expected range.

• Always include an else statement when working with data validation or user inputs
• Return meaningful error messages that help identify the issue
• Consider raising custom exceptions for more complex error handling scenarios

This pattern becomes especially critical in production environments where unexpected inputs could cause downstream issues. The explicit error message makes debugging faster and helps maintain code quality.

Confusing and and or operators in elif conditions

Misusing logical operators and and or in elif conditions creates impossible or unintended logic paths. The code below demonstrates a common mistake where using and creates a condition that can never evaluate to True because a variable cannot equal two different values simultaneously.

payment_method = "credit"
if payment_method == "credit" and payment_method == "debit":  # Cannot be both at once
    print("Card payment")
else:
    print("Other payment")

The condition payment_method == "credit" and payment_method == "debit" creates a logical impossibility. A single variable can't simultaneously hold two different values. Let's examine the corrected implementation below.

payment_method = "credit"
if payment_method == "credit" or payment_method == "debit":
    print("Card payment")
else:
    print("Other payment")

The corrected code uses the or operator to check if payment_method matches either "credit" or "debit". This creates a logical condition that can actually be satisfied, unlike the original version with and which required impossible simultaneous values.

• Watch for logical operators in conditions that check the same variable against different values
• Use or when any of multiple conditions should trigger the code block
• Use and only when all conditions must be true simultaneously

This pattern appears frequently in input validation and category matching. Testing your conditions with different inputs helps catch these logical errors early.