Learn When to Use elif in Python: Absolute Beginners Tutorial

The elif keyword is what Python uses to test a second (or third, or fourth) condition when the first one is False. Understanding exactly when to reach for elif instead of a second if is one of those early decisions that shapes how clearly your code communicates.

Every program eventually needs to make decisions. Python's if statement handles a single decision: do this or skip it. But real problems have more than two outcomes. A traffic light is not just red or not-red. A grade is not just passing or failing. elif is the mechanism Python provides for mapping those additional outcomes without re-evaluating everything from scratch.

What elif Does and Why It Exists

elif is a contraction of "else if." It attaches to an existing if block and supplies a new condition to test — but only when the preceding condition was False. The moment any condition in the chain evaluates to True, Python executes that block and skips every remaining elif and else.

The simplest form looks like this:

temperature = 85

if temperature >= 100:
    print("boiling")
elif temperature >= 70:
    print("warm")
else:
    print("cool")

With temperature = 85, the first condition (temperature >= 100) is False. Python moves to the elif, finds 85 >= 70 is True, prints "warm", and stops. The else block never runs.

The three building blocks of a full conditional chain are worth naming clearly:

• if — opens the chain; always required; tested first.
• elif — optional; tested only when all preceding conditions were False; you can have as many as needed.
• else — optional; has no condition; runs only when every preceding condition was False.

A practical example that matches this pattern is mapping a numeric score to a letter grade. There are five distinct outcomes, none of which should overlap:

score = 78

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(grade)  # C

Because the conditions descend in value, each range is implicitly bounded. When Python reaches score >= 70, it already knows the score is below 80 (otherwise the previous elif would have matched). This is one of the cleaner patterns in Python — each branch handles exactly one slice of the number line.

elif vs. a Second if Statement

New Python writers sometimes wonder why elif exists at all. After all, you could write a second if statement and get a result. The difference is subtle but important: when you write a chain of independent if statements, Python evaluates every one of them. When you use elif, Python stops as soon as a match is found.

Consider this side-by-side comparison using a variable role:

# --- Using separate if statements ---
role = "admin"

if role == "admin":
    print("full access")    # prints
if role == "editor":
    print("edit access")    # does not print
if role == "viewer":
    print("read-only")      # does not print

# All three conditions are evaluated regardless.


# --- Using elif ---
if role == "admin":
    print("full access")    # prints, chain stops here
elif role == "editor":
    print("edit access")    # skipped
elif role == "viewer":
    print("read-only")      # skipped

For string comparisons the difference is mainly one of efficiency and intent. But with numeric comparisons the difference matters in a more concrete way:

score = 95

# --- Separate if statements: two blocks fire ---
if score >= 90:
    print("You earned an A")    # prints
if score >= 80:
    print("You earned a B")     # also prints — unintended!

# --- elif: only one block fires ---
if score >= 90:
    print("You earned an A")    # prints
elif score >= 80:
    print("You earned a B")     # skipped correctly

With a score of 95 and two separate if statements, both conditions are True, so both blocks print. That is logically wrong for a grading system — a score of 95 should map to exactly one letter grade. elif enforces that mutual exclusivity.

Chaining Multiple elif Clauses

Python allows as many elif clauses as a problem requires. There is no syntactic limit. In practice, the need for more than four or five branches often signals that a dictionary lookup or Python's match statement (introduced in Python 3.10) would express the logic more cleanly — but for straightforward range-based decisions, a well-ordered chain of elif clauses is idiomatic and clear.

Here is a real-world example: a function that returns a time-of-day label based on the hour in 24-hour format.

def time_of_day(hour):
    """Return a label for the given 24-hour clock value."""
    if hour < 0 or hour > 23:
        return "invalid hour"
    elif hour < 6:
        return "night"
    elif hour < 12:
        return "morning"
    elif hour < 17:
        return "afternoon"
    elif hour < 21:
        return "evening"
    else:
        return "night"

print(time_of_day(3))   # night
print(time_of_day(9))   # morning
print(time_of_day(14))  # afternoon
print(time_of_day(19))  # evening
print(time_of_day(23))  # night

A few things worth noting in that function. The first condition validates the input and returns early if the value is out of range — a common pattern that keeps the rest of the chain clean. Each subsequent elif only runs if all previous conditions were False, so the boundaries are implicitly enforced. The final else catches hours 21 through 23 without requiring an explicit comparison.

What happens when no condition matches

If no condition in an if/elif chain matches and there is no else, Python does nothing. Execution continues on the line after the entire block without error. This is valid and sometimes exactly what you want:

status_code = 200

if status_code == 404:
    print("not found")
elif status_code == 500:
    print("server error")
# No else — 200 produces no output and that is intentional.
# Code continues here regardless.

elif with compound conditions

The condition after elif can be any valid Python boolean expression — comparisons, function calls, membership tests, and compound conditions using and, or, and not.

age = 17
has_id = False

if age >= 21:
    print("admitted")
elif age >= 18 and has_id:
    print("admitted with ID")
elif age >= 16:
    print("minor — restricted access")
else:
    print("not admitted")

Here, the second elif uses a compound condition. Both age >= 18 and has_id must be True for that branch to fire. With age = 17 and has_id = False, neither the first condition nor the second matches, so Python falls through to the third elif and prints "minor — restricted access".

"Flat is better than nested." — The Zen of Python (PEP 20)

Long elif chains stay flat — one level of indentation — which is preferable to deeply nested if statements. If you find yourself nesting if inside if inside if, consider whether elif at the outer level would express the same logic without the extra indentation.

Python Learning Summary Points

1. elif is only evaluated when all preceding if and elif conditions in the same chain were False. The moment a match is found, all remaining branches are skipped.
2. When conditions are mutually exclusive — meaning only one should be True at a time — always use elif rather than a second independent if. A second if can fire even when the first one already did.
3. Order your conditions from most restrictive to least restrictive. For descending numeric thresholds, each boundary is implicitly enforced because Python has already ruled out higher values by the time it reaches a lower elif.
4. The else clause is optional. Without it, if no condition matches, Python silently moves past the entire block. Add else when your program requires a guaranteed fallback or must set a value in every case.
5. Long elif chains (more than five or six branches) may be a sign to consider a dictionary mapping or, for Python 3.10+, a match statement — both of which can express the same logic with less repetition.

The rule of thumb is straightforward: use elif whenever a new condition should only be checked after a previous condition has failed, and whenever you want to guarantee that at most one branch runs. Everything else — independent checks, multiple simultaneous conditions — belongs in separate if statements.