Making decisions

Make a day04 folder for today’s files, open it in your editor, and run each script from its terminal, as on Days 1 to 3.

Every program so far has run every line, top to bottom, every time. Real programs make choices: print a different grade for a different score, charge a child less than an adult, answer the command the user typed. Today you learn to ask questions about values and to run code only when the answer is yes.

To decide anything, a program first needs a question with a yes-or-no answer: is the score at least 50? Is the password the one we expected? On Day 2 you met the two values that answer such questions, True and False, and on Day 3 you used == to check whether two strings match. Python has six operators that ask questions like these.

A comparison operator compares two values and gives a bool: True if the comparison holds, False if it does not. An expression that gives a bool is called a condition.

Two-character operators are typed with no space between the characters, and the = always comes second: <=, not =<. Read != as “is not equal to”; the ! means “not”.

>>> score = 72
>>> score > 50
True
>>> score < 50
False
>>> score == 72
True
>>> score != 72
False
>>> score >= 72
True
>>> score <= 71
False

score is 72, so score > 50 is True. score >= 72 is True because “or equal to” counts 72 itself, while score <= 71 is False.

A comparison is an expression like any other, so you can store its result in a variable, print it, or compare the result of a calculation:

temperature = 31.5
is_hot = temperature > 30
is_freezing = temperature <= 0
print("Hot:", is_hot)
print("Freezing:", is_freezing)
print("Feels like summer:", temperature + 2 >= 30)

Hot: True
Freezing: False
Feels like summer: True

Comparisons also work across types and on strings:

>>> 7 == 7.0
True
>>> 5 == "5"
False
>>> "apple" < "banana"
True
>>> "cat" < "catch"
True
>>> "Zebra" < "apple"
True

• An int and a float compare by value, so 7 == 7.0 is True.
• A number never equals a string, so 5 == "5" is False. No error, just False.
• Strings compare alphabetically, character by character from the left. "apple" < "banana" because a comes before b. When one string runs out first, as "cat" does against "catch", the shorter one comes first.
• Every capital letter comes before every small letter, so "Zebra" < "apple" is True. Python compares the code number that the computer stores for each character, and the capitals have the smaller numbers. Use lower() on both sides when you want a true dictionary order.

age = input("Age: ")
print("Adult:", age >= 18)

Age: 15
Traceback (most recent call last):
  File ".../day04/age_check.py", line 2, in <module>
    print("Adult:", age >= 18)
                    ^^^^^^^^^
TypeError: '>=' not supported between instances of 'str' and 'int'

>>> 0.1 + 0.2 == 0.3
False
>>> round(0.1 + 0.2, 2) == 0.3
True

>>> price = 4.5
>>> price >= 4.5
>>> price * 2 != 9
>>> "Dog" == "dog"
>>> "ant" < "Bee"
>>> 10 == 10.0

>>> price = 4.5
>>> price >= 4.5
True
>>> price * 2 != 9
False
>>> "Dog" == "dog"
False
>>> "ant" < "Bee"
False
>>> 10 == 10.0
True

A water park ride is for ages 13 to 19. With one comparison you can check “at least 13” or “at most 19”, but not both. In maths you would write 13 ≤ age ≤ 19, and Python lets you write exactly that.

A chained comparison puts several comparisons in a row, such as 13 <= age <= 19. It is True only when every link in the chain is true: 13 <= age and age <= 19. The value in the middle is used in both links.

>>> age = 15
>>> 13 <= age <= 19
True
>>> age = 25
>>> 13 <= age <= 19
False
>>> 0 < 5 < 10 < 20
True

With age 15, both 13 <= 15 and 15 <= 19 hold, so the chain is True. With 25 the second link, 25 <= 19, fails, so the whole chain is False. A chain can be any length: 0 < 5 < 10 < 20 checks three links.

Read a chain like a number line, smallest on the left: low <= value <= high means “value is between low and high”. Use < at an end to leave that end out: 0 < minutes < 60 allows 1 to 59 when minutes is a whole number.

>>> age = 30
>>> age >= 13 <= 19
True
>>> 13 <= age <= 19
False

Many rules need more than one condition. “You can ride if you are tall enough and old enough.” “The shop is closed on Saturday or Sunday.” A chain handles ranges of one value, but these rules join conditions about different things. Python joins conditions with three words.

A logical operator combines bools into a new bool:

• and gives True only when both sides are True.
• or gives True when at least one side is True. (It is also True when both are; in everyday English “or” sometimes means “one but not both”, but Python’s or never does.)
• not goes in front of a single bool and flips it: not True is False.

A truth table lists every combination:

>>> age = 16
>>> has_ticket = True
>>> age >= 18 and has_ticket
False
>>> age >= 18 or has_ticket
True
>>> not has_ticket
False
>>> not age >= 18
True

age >= 18 is False, so and gives False even though has_ticket is True, while or needs only one, so it gives True. In not age >= 18, the comparison happens first, giving False, and not flips it to True.

The chained comparison from 4.2 is a short way of writing and: 13 <= age <= 19 means the same as 13 <= age and age <= 19.

height = 125
age = 9
with_adult = True
tall_enough = height >= 120
can_ride = tall_enough and (age >= 10 or with_adult)
print("Tall enough:", tall_enough)
print("Can ride:", can_ride)

Tall enough: True
Can ride: True

Without parentheses, Python groups the operators in a fixed order: comparisons bind tightest, then not, then and, then or. Think of and as multiplication and or as addition: and binds tighter, so a or b and c means a or (b and c). Grouping only decides which parts belong together; Python still works out the parts from left to right, as 4.4 shows.

>>> is_weekend = True
>>> is_holiday = False
>>> is_raining = True
>>> is_weekend or is_holiday and not is_raining
True
>>> (is_weekend or is_holiday) and not is_raining
False

>>> x = 7
>>> x > 5 and x < 10
>>> x < 5 or x > 10
>>> not x == 7
>>> x > 5 or x > 100 and x < 0

>>> x = 7
>>> x > 5 and x < 10
True
>>> x < 5 or x > 10
False
>>> not x == 7
False
>>> x > 5 or x > 100 and x < 0
True

Suppose you want to know whether a class’s average score is over 50, but the class might have no scores yet. Working out the average means dividing by the count, and Day 2 showed that dividing by zero stops the program. You need the check “is there anything to average?” to protect the division.

Look at the truth table in 4.3 again. If the left side of and is False, the answer is False whatever the right side is. If the left side of or is True, the answer is True whatever the right side is. Python takes advantage of this: it works out the left side first, and when that already decides the answer, it does not run the right side at all. This is called short-circuit evaluation.

total = 0
count = 0
print(count > 0 and total / count > 50)
print(count == 0 or total / count > 50)

False
True

In line 3, count > 0 is False, so and stops there and gives False; the division total / count never runs. In line 4, count == 0 is True, so or stops and gives True. Neither line divides by zero.

Now swap the order, so the division comes first:

total = 0
count = 0
print(total / count > 50 and count > 0)

Traceback (most recent call last):
  File ".../day04/short_circuit_crash.py", line 3, in <module>
    print(total / count > 50 and count > 0)
          ~~~~~~^~~~~~~
ZeroDivisionError: division by zero

The left side runs first, and it divides by zero before Python ever reaches count > 0. The same two conditions are safe in one order and a crash in the other.

You can now ask questions, but every line still runs whatever the answer. To print “Drink plenty of water” only on hot days, a program needs to skip lines when a condition is False. Day 1 said indentation shows which lines belong together in a group, and that you would build those groups on Day 4. Here they are.

An if statement runs a group of lines only when its condition is True. Its shape:

if condition:
    statement
    statement

• if is a keyword (Day 2 listed it), followed by the condition.
• The colon : ends the line and means “a group of lines follows”.
• The indented lines below form a block: the lines that belong to the if. Python style uses 4 spaces per level; most editors indent the next line for you when you press Enter after a colon.
• The block ends at the first line that goes back to the left edge. That line is not part of the if, so it always runs.

Choosing between paths like this is called selection, and a block can hold as many lines as you need.

temperature = 31
print("Checking the weather...")
if temperature > 30:
    print("It is hot today.")
    print("Drink plenty of water.")
print("Have a good day!")

Checking the weather...
It is hot today.
Drink plenty of water.
Have a good day!

Now change only the temperature, to 18:

temperature = 18
print("Checking the weather...")
if temperature > 30:
    print("It is hot today.")
    print("Drink plenty of water.")
print("Have a good day!")

Checking the weather...
Have a good day!

18 > 30 is False, so Python skips the whole block, both indented lines, and continues at line 6. The indentation is what tells Python that line 5 belongs to the if and line 6 does not.

If you forget to indent the block, Python cannot tell that the line belongs to the if, and nothing runs:

score = 75
if score >= 50:
print("Pass")

  File ".../day04/if_no_indent.py", line 3
    print("Pass")
    ^^^^^
IndentationError: expected an indented block after 'if' statement on line 2

score = 75
if score = 100:
    print("Perfect score!")

  File ".../day04/if_assign.py", line 2
    if score = 100:
       ^^^^^^^^^^^
SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

money = 20
price = 15
print("Looking at the shoes...")
if money >= price:
    print("Buying them.")
    money = money - price
if money < price:
    print("Saving up instead.")
print("Money left:", money)

Looking at the shoes...
Buying them.
Saving up instead.
Money left: 5

days_late = 4
if days_late > 0
    print("Fine:", days_late * 0.25)
print("Thank you!")

SyntaxError: expected ':'

days_late = 4
if days_late > 0:
    print("Fine:", days_late * 0.25)
print("Thank you!")

Fine: 1.0
Thank you!

Question 5 showed a problem: two separate if statements are two separate questions, and both can run. Often you want exactly one of two paths: buy the shoes or save up, never both.

An else clause gives an if a second block that runs when the condition is False. else has no condition of its own, sits at the same indentation as its if, and ends with a colon:

money = 20
price = 15
print("Looking at the shoes...")
if money >= price:
    print("Buying them.")
    money = money - price
else:
    print("Saving up instead.")
print("Money left:", money)

Looking at the shoes...
Buying them.
Money left: 5

20 >= 15 is True, so the if block runs and the else block is skipped. The condition is checked once, before money changes, so the purchase cannot trigger the second message. With money = 10, the if block would be skipped and the else block would run instead. One of the two always runs, never both.

For more than two paths, add elif (“else if”) clauses between the if and the else. Each elif has its own condition. Together they form an if chain: Python checks the conditions from the top down, runs the block of the first one that is True, and skips everything else in the chain. The else at the bottom catches every case that no condition matched. It is optional; without it, a chain where nothing matches runs no block at all.

temperature = 12
if temperature >= 25:
    advice = "T-shirt weather"
elif temperature >= 15:
    advice = "Bring a light jacket"
elif temperature >= 5:
    advice = "Wear a coat"
else:
    advice = "Wear a coat, hat, and gloves"
print(f"{temperature} degrees: {advice}")

12 degrees: Wear a coat

Translating English rules into a chain works the same way every time: one rung per rule, in the order the rules must be checked, with else for “anything else”.

temperature = 30
if temperature >= 5:
    advice = "Wear a coat"
elif temperature >= 15:
    advice = "Bring a light jacket"
elif temperature >= 25:
    advice = "T-shirt weather"
else:
    advice = "Wear a coat, hat, and gloves"
print(f"{temperature} degrees: {advice}")

30 degrees: Wear a coat

weight = 5
if weight > 20:
    cost = 25
elif weight > 5:
    cost = 12
elif weight > 2:
    cost = 8
else:
    cost = 5
print("Cost:", cost)

Cost: 8

A program asks for a nickname, and the user just presses Enter. input() returns the empty string "". You could write if nickname == "":, but Python has a shorter way, because a condition does not have to be a bool.

Any value can be used as a condition. Python treats some values as false and all the rest as true. A value that acts as False in a condition is falsy; a value that acts as True is truthy. The falsy values are the “empty” or “nothing” ones:

• False and None
• zero: 0 and 0.0
• the empty string ""
• [], an empty list, which you meet on Day 6

Everything else is truthy: any non-zero number (negative ones too), and any string with at least one character, even " ", "0", or "False". The built-in function bool() shows how Python treats a value:

>>> bool(0)
False
>>> bool(0.0)
False
>>> bool("")
False
>>> bool(None)
False
>>> bool([])
False
>>> bool(42)
True
>>> bool(-1)
True
>>> bool("0")
True
>>> bool(" ")
True

"0" is a one-character string, not the number zero, so it is truthy. " " holds a space, so it is not empty.

nickname = input("Nickname: ").strip()
if nickname:
    print(f"Hi, {nickname}!")
else:
    print("Hi, friend!")

Nickname:
Hi, friend!

not works with truthiness too: if not nickname: reads “if there is no nickname”.

answer = input("Continue? ").strip().lower()
if answer == "yes" or "y":
    print("Continuing...")
else:
    print("Stopping.")

Continue? no
Continuing...

answer = input("Continue? ").strip().lower()
if answer == "yes" or answer == "y":
    print("Continuing...")
else:
    print("Stopping.")

Continue? no
Stopping.

count = 0
name = "0"
note = None
if count:
    print("A")
if name:
    print("B")
if not note:
    print("C")
if count == 0 and name:
    print("D")

B
C
D

None means “no value yet” (Day 2). Checking for it with if not value: is risky, because 0 and "" are falsy too, and those are real values. Python has an operator that asks precisely “is this None?”

Every value in a running program is an object: a thing stored in the computer’s memory. A variable name refers to an object. Two different objects can hold equal values, like two printed copies of the same book: same words, different copies. Python has two different questions:

• == asks about equality: do the two values have the same contents? Two copies of the same book are equal.
• is asks about identity: are both sides the very same object? Two copies are not the same copy.

There is only ever one None object in a program, so value is None is a precise test for “is this None?”, and is not asks the opposite. This is the standard way to check for None:

>>> result = None
>>> result is None
True
>>> result is not None
False
>>> result = 0
>>> result is None
False
>>> result is not None
True

When result is 0, result is None is False: 0 is a real value, not “no value”.

discount = 0
if discount:
    print("Truthy check: discount is", discount)
if discount is not None:
    print("None check: discount is", discount)

None check: discount is 0

For everything except None, compare values with ==. Whether Python keeps one object or several for equal numbers or equal strings is up to Python. It can differ between versions, and even between the REPL and a script, so is with numbers or strings can give a different answer from one run to the next.

To print “1 ticket” but “3 tickets”, you could write an if / else that assigns one of two words:

if tickets == 1:
    word = "ticket"
else:
    word = "tickets"

Four lines to pick one of two values. Python has a one-line form for this job.

A conditional expression picks one of two values based on a condition:

value_if_true if condition else value_if_false

Python works out the condition first. If it is truthy, the whole expression gives value_if_true; otherwise it gives value_if_false. It reads almost like English: “"ticket" if there is one ticket, else "tickets"”. Because it is an expression (it gives a value), it can go anywhere a value can: on the right of =, inside print, or inside an f-string.

tickets = 1
word = "ticket" if tickets == 1 else "tickets"
print(f"You bought {tickets} {word}.")
tickets = 3
word = "ticket" if tickets == 1 else "tickets"
print(f"You bought {tickets} {word}.")
number = 7
print(number, "is", "even" if number % 2 == 0 else "odd")

You bought 1 ticket.
You bought 3 tickets.
7 is odd

Keep conditional expressions short. When either side needs more than a value, or there are more than two choices, an if chain is clearer.

tickets = 3
word = "tickets" if tickets > 1
print(word)

  File ".../day04/missing_else.py", line 2
    word = "tickets" if tickets > 1
           ^^^^^^^^^^^^^^^^^^^^^^^^
SyntaxError: expected 'else' after 'if' expression

>>> score = 49
>>> "pass" if score >= 50 else "fail"
>>> score = score + 1
>>> "pass" if score >= 50 else "fail"
>>> items = 0
>>> f"{items} item" + ("" if items == 1 else "s")

>>> score = 49
>>> "pass" if score >= 50 else "fail"
'fail'
>>> score = score + 1
>>> "pass" if score >= 50 else "fail"
'pass'
>>> items = 0
>>> f"{items} item" + ("" if items == 1 else "s")
'0 items'

A program that responds to commands often checks one value against a list of fixed choices: if light == "green":, elif light == "yellow":, elif light == "red":, and so on. Each rung repeats light ==. Python has a statement designed for exactly this shape.

A match statement compares one value, the subject, against a series of case clauses. Each case names a pattern; today every pattern is a literal, a fixed value written straight into the code, such as "green" or 3. Python checks the cases from the top down, runs the block of the first case whose value equals the subject, and skips the rest, just like an if chain.

light = "yellow"
match light:
    case "green":
        print("Go")
    case "yellow":
        print("Slow down")
    case "red":
        print("Stop")
    case _:
        print("Unknown light")

Slow down

To let several values share one block, join them with |, read “or”:

day = "sun"
match day:
    case "sat" | "sun":
        print("Weekend: open 10:00 to 16:00")
    case "fri":
        print("Friday: open 8:00 to 17:00")
    case _:
        print("Weekday: open 8:00 to 20:00")

Weekend: open 10:00 to 16:00

"sun" does not equal "sat", but it equals "sun", so the first case matches. match can do much more than compare with fixed values; for now, use it when one value is compared against several literals, and use an if chain for anything else, such as ranges with < or >.

command = "Help"
match command:
    case "help":
        print("Commands: start, stop, help")
    case "start":
        print("Starting...")
print("Done.")

Done.

size = "m"
match size:
    case "S" | "XS":
        price = 12
    case "M" | "L":
        price = 15
    case _:
        price = 18
print("Size", size, "costs", price)

Size m costs 18

A cinema charges 6.00 for children under 12, 7.00 for seniors 65 and over, and 10.00 for everyone else. On Tuesdays every ticket is 2.00 off, and on Fridays teenagers from 13 to 17 get free popcorn. This run types 15 and Friday:

age = int(input("Age: "))
day = input("Day: ").strip().lower()

if age < 12:
    ticket = "child"
    price = 6.0
elif age >= 65:
    ticket = "senior"
    price = 7.0
else:
    ticket = "standard"
    price = 10.0

discount = 2.0 if day == "tuesday" else 0.0
price = price - discount
print(f"Ticket: {ticket}, {price:.2f}")

if day == "friday" and 13 <= age <= 17:
    print("Teen Friday: free popcorn!")

Age: 15
Day: Friday
Ticket: standard, 10.00
Teen Friday: free popcorn!

The if chain gives every customer exactly one ticket type, with the narrow cases (under 12, 65 and over) checked before else catches the rest. Line 14 uses a conditional expression because it only picks one of two values. Line 18 joins a string check and a chained range check with and. Line 2’s lower() is what makes Friday match "friday".

• Comparison operators give True or False; arithmetic happens first, and strings compare alphabetically with capitals first. A chained comparison like low <= value <= high checks a range.
• and needs both sides true, or at least one, and not flips. and binds tighter than or, and short-circuit evaluation skips the right side when the left decides, so put safety checks first.
• An if chain runs the block of the first true condition and skips the rest; else catches everything else. Indentation marks each block.
• False, None, 0, 0.0, "", and an empty list are falsy; everything else is truthy.
• == compares values; is compares objects. Use is None for None and == for everything else.
• A conditional expression a if condition else b picks a value, and match / case compares one value against fixed choices.

Do these in your day04 folder. Type each program yourself, run it, and only then open the answer. Run each one several times with different typed input, including values right on a boundary.

score = float(input("Score: "))
if not 0 <= score <= 100:
    print("Scores run from 0 to 100.")
elif score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
elif score >= 60:
    print("Grade: D")
else:
    print("Grade: F")

Score: 89.5
Grade: B

year = int(input("Year: "))
if year % 400 == 0:
    is_leap = True
elif year % 100 == 0:
    is_leap = False
elif year % 4 == 0:
    is_leap = True
else:
    is_leap = False

if is_leap:
    print(f"{year} is a leap year.")
else:
    print(f"{year} is not a leap year.")

Year: 1900
1900 is not a leap year.

>>> year = 2024
>>> year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
True
>>> year = 1900
>>> year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
False
>>> year = 2000
>>> year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
True
>>> year = 2023
>>> year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
False

print("Commands: hours, price, help")
command = input("Command: ").strip().lower()
match command:
    case "hours":
        print("Open 8:00 to 18:00, Monday to Saturday.")
    case "price":
        print("A coffee costs 3.50.")
    case "help":
        print("Type hours, price, or help.")
    case _:
        print(f"Unknown command: {command}")

Commands: hours, price, help
Command: Hours
Open 8:00 to 18:00, Monday to Saturday.

Commands: hours, price, help
Command: price
A coffee costs 3.50.

Commands: hours, price, help
Command: help
Type hours, price, or help.

Commands: hours, price, help
Command: coffee
Unknown command: coffee

items_in_cart = 3
coupon = ""
total = 42.0
if items_in_cart > 5 or total > 40 and not coupon:
    print("Free delivery")
else:
    print("Delivery: 4.99")
if coupon:
    print("Coupon:", coupon)
size = "small" if items_in_cart < 5 else "large"
print("Order size:", size)

Free delivery
Order size: small

color = "green"
if color == "red" or "blue":
    print("Warm or cool")
else:
    print("Something else")

temperature = 18
if temperature > 25:
    print("Hot")
print("Checked the temperature.")
else:
    print("Not hot")

temperature = 18
if temperature > 25:
    print("Hot")
else:
    print("Not hot")
print("Checked the temperature.")

Not hot
Checked the temperature.

high_score = 0
if not high_score:
    print("Truthy check: no games played yet")
if high_score is None:
    print("None check: no games played yet")
else:
    print("None check: high score is", high_score)

Truthy check: no games played yet
None check: high score is 0

command = " STOP "
match command.strip().lower():
    case "go" | "start":
        status = "running"
    case "stop" | "halt":
        status = "stopped"
    case _:
        status = "unknown"
symbol = ">" if status == "running" else "#"
print(symbol, status)

# stopped

The official Python Tutorial covers today’s statements in More Control Flow Tools: if Statements and More Control Flow Tools: match Statements. The match section goes well beyond literal patterns; read its first examples now and the rest later.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can compare numbers and strings and predict the result. Reread
• I can write a range check as a chained comparison. Reread
• I can combine conditions with and, or, and not, and add parentheses where needed. Reread
• I can explain short-circuit evaluation and use it to guard a division. Reread
• I can write an if statement with a correctly indented block. Reread
• I can translate English rules into an if, elif, and else chain. Reread
• I can say which values are truthy and which are falsy. Reread
• I can check for None with is and compare values with ==. Reread
• I can pick one of two values with a conditional expression. Reread
• I can match a value against fixed choices with match and case. Reread