Decisions with if, elif and else

Almost every useful program has to choose: charge one price or another, accept an answer or ask again, print a warning or stay quiet. Python’s if statement runs a block of code only when a condition is true. Add elif and else and you can describe several cases, of which Python runs exactly one.

The parts of an if statement

An if statement starts with the word if, a condition and a colon. The lines under it that are indented further form its block, and they run only when the condition is true. An else: line at the same indentation as the if starts a second block, for when the condition is false:

temperature = 41

if temperature > 40:
    print("Heat warning")
    print("Carry water")
else:
    print("A normal day")

print("Forecast done")

Heat warning
Carry water
Forecast done

The temperature is above 40, so both indented lines under if ran and the else block was skipped. The last line is not indented at all, so it is not part of either block: it runs whatever the temperature is. Change 41 to 25 with Edit and run it again to see the other path.

Three rules make this work:

• The indentation is the block. Python has no braces or end keywords; a block lasts until a line that is indented less. PEP 8, Python’s style guide, asks for four spaces per level.
• A block cannot be empty. When you have nothing to put in one yet, write pass, a statement that does nothing, or ..., which people often use the same way.
• Tabs and spaces do not mix. If some lines are indented with tabs and others with spaces in a way whose meaning depends on how wide a tab is, Python stops with a TabError. Let your editor indent with spaces only.

Forget to indent, and the program does not run at all:

temperature = 41
if temperature > 40:
print("Heat warning")

  File "missing_block.py", line 3
    print("Heat warning")
    ^^^^^
IndentationError: expected an indented block after 'if' statement on line 2

The message names the line of the if that is missing its block. Like any syntax error, it stops the whole file before the first line runs, so not even the assignment on line 1 happened.

Any value can be a condition

A condition is usually a comparison such as temperature > 40, which is either True or False. But if accepts any value and asks whether it counts as true. False, None, zero (0, 0.0) and empty strings, lists and other empty containers count as false; every other value counts as true. So if name: means “if name is not an empty string”, a short form you will see often. Keep this rule in mind: it explains the classic if mistake shown in the section on x == 1 or 2 below.

Several cases with elif

elif, short for “else if”, adds more conditions between the if and the else. Python tests them from the top, runs the block of the first one that is true, and skips the rest of the chain without even testing it. When no condition is true, the else block runs, if there is one.

Suppose electricity is billed in slabs, where each band of units has its own rate. The function below works out a month’s charge with made-up rates: 3 for each of the first 100 units, 5 for each of the next 200 and 8 for every unit above 300.

# A month's energy charge, worked out slab by slab: the first 100
# units cost 3 each, the next 200 cost 5 each, and every unit above
# 300 costs 8. The rates are made up for this example.

def energy_charge(units):
    if units <= 100:
        return units * 3
    elif units <= 300:
        return 100 * 3 + (units - 100) * 5
    else:
        return 100 * 3 + 200 * 5 + (units - 300) * 8


print("80 units:", energy_charge(80))
print("100 units:", energy_charge(100))
print("101 units:", energy_charge(101))
print("300 units:", energy_charge(300))
print("301 units:", energy_charge(301))
print("450 units:", energy_charge(450))

80 units: 240
100 units: 300
101 units: 305
300 units: 1300
301 units: 1308
450 units: 2500

Read the chain the way Python does. For 450 units, units <= 100 is false, units <= 300 is false, so the else block runs. For 250 units the second test is true, and Python never looks at the else. The elif needs no lower limit: it is tested only after units <= 100 was false, so every value that reaches it is already above 100. Written on its own, the same test would be the chained comparison 100 < units <= 300.

The program tries 100 and 101, and 300 and 301, on purpose. Mistakes in chains like this hide at the boundaries, where < and <= give different answers, so test the value on each edge and the one just past it: at 301 units, exactly one unit is charged at the top rate, so the charge is 1300 + 8. And because the chain ends with else, every number of units gets a charge: no case falls through the gaps.

A common mistake: tests in the wrong order

The order of the tests matters as much as the tests themselves. Here the two conditions of the same chain are swapped:

# The same slabs with the two tests swapped: the wider one is first.

def energy_charge(units):
    if units <= 300:
        return 100 * 3 + (units - 100) * 5
    elif units <= 100:
        return units * 3
    else:
        return 100 * 3 + 200 * 5 + (units - 300) * 8


print("80 units:", energy_charge(80))
print("250 units:", energy_charge(250))

80 units: 200
250 units: 1050

80 units now cost 200 instead of 240. units <= 300 is also true for 80, so the second slab’s formula runs, and the elif units <= 100 block can never run for any number. Put the narrowest test first, or give every test both of its limits so that the order no longer matters.

The x == 1 or 2 mistake

Here is a check for weekend prices that looks right and is not:

day = "Tue"

if day == "Sat" or "Sun":
    print("Weekend price")
else:
    print("Weekday price")

print(day == "Sat" or "Sun")

if day == "Sat" or day == "Sun":
    print("Weekend price")
else:
    print("Weekday price")

if day in ("Sat", "Sun"):
    print("Weekend price")
else:
    print("Weekday price")

Weekend price
Sun
Weekday price
Weekday price

On a Tuesday the first if still printed “Weekend price”. Python reads day == "Sat" or "Sun" as (day == "Sat") or "Sun", because == is applied before or. Then or works like this: if its left side counts as true, the result is the left side; otherwise the result is the right side. day == "Sat" is False, so the whole condition is the string "Sun", as the second line of output shows, and a non-empty string counts as true. The if block runs on every day of the week.

The last two tests in the program are the fixes. Either compare the variable each time, day == "Sat" or day == "Sun", or ask whether it is one of several values with in: day in ("Sat", "Sun"). The second form stays short when the list grows. The same trap catches numbers: if x == 1 or 2: is always true, while if x in (1, 2): is what was meant.

A choice in one line: conditional expressions

When all you need is one of two values, a conditional expression does it inside a single line: value_if_true if condition else value_if_false.

age = 16
label = "adult" if age >= 18 else "minor"
print(age, label)

tickets = 1
print(tickets, "ticket" if tickets == 1 else "tickets")
tickets = 3
print(tickets, "ticket" if tickets == 1 else "tickets")

# Only the chosen side is worked out, so no division happens here.
total = 0
count = 0
average = total / count if count > 0 else 0
print("Average:", average)

16 minor
1 ticket
3 tickets
Average: 0

Python works out the condition first and then only the side it chose. That is why the last example is safe: count is 0, so total / count is never calculated and there is no ZeroDivisionError. Use conditional expressions for short choices between two values, like a label or a word that depends on a number. When each case does something, when there are more than two cases, or when you are tempted to put one conditional expression inside another, write an if statement instead: it is easier to read and to change.

Flatter code with guard clauses

Conditions inside conditions push the main work further and further to the right. Both versions of withdraw below give the same answers; compare how they read:

def withdraw(balance, amount):
    if amount > 0:
        if amount <= balance:
            return f"Paid {amount}, {balance - amount} left"
        else:
            return "Not enough money"
    else:
        return "The amount must be more than 0"


print(withdraw(500, 200))
print(withdraw(500, 900))
print(withdraw(500, -5))

Paid 200, 300 left
Not enough money
The amount must be more than 0

def withdraw(balance, amount):
    if amount <= 0:
        return "The amount must be more than 0"
    if amount > balance:
        return "Not enough money"
    return f"Paid {amount}, {balance - amount} left"


print(withdraw(500, 200))
print(withdraw(500, 900))
print(withdraw(500, -5))

Paid 200, 300 left
Not enough money
The amount must be more than 0

The second version checks for each problem first and returns straight away. Because return ends the function, the cases that get past both checks need no else, and the normal case sits at the bottom, not indented any further. These early checks are called guard clauses. They keep each rule on its own two lines, so adding a third rule (a daily limit, say) means adding two lines rather than another level of nesting.

Python 3.14: a clearer message for elif after else

An else block must be the last part of its chain. Put an elif after it and Python refuses the file:

units = 120
if units <= 100:
    print("First slab")
else:
    print("Above 100 units")
elif units <= 300:
    print("Second slab")

  File "elif_after_else.py", line 6
    elif units <= 300:
    ^^^^
SyntaxError: 'elif' block follows an 'else' block

When you compare one value with many fixed values, such as commands typed by a user, the match statement from a later lesson of this module can be easier to read than a long elif chain.

Key takeaways

• An if block is the indented lines after the colon; four spaces per level, never a mix of tabs and spaces. Write pass when a block has nothing to do yet.
• In an if/elif/else chain Python runs only the first block whose condition is true; finish with else so that every case is covered, and test the values on each boundary.
• Order the tests from the narrowest to the widest, or give each test both of its limits.
• x == 1 or 2 is always true; write x == 1 or x == 2, or x in (1, 2).
• a if condition else b picks one of two values and works out only the side it picks.
• Guard clauses (check, then return early) keep functions flat and easy to extend.