Making decisions

A program that runs the same lines every time can only do one job. The moment it can look at what it has and choose, it can do many. That's what this lesson adds, and it rests on a type you met in lesson 2 and haven't used yet: bool, which has exactly two values.

A comparison produces a value

Type a comparison at the prompt and look at what comes back.⁴

>>> 7 > 3
True
>>> 7 == 3
False

True and False aren't words Python prints for your benefit. They're values, the only two of type bool, and you can put them in a name like anything else:

>>> is_open = 7 > 3
>>> type(is_open)
<class 'bool'>

Six comparison operators, and the one that causes trouble is the first.

One equals sign is the instruction from lesson 2: make this name refer to this value. Two equals signs ask a question. Confuse them and Python stops you before anything runs:

age = 17
if age = 18:
    print("Just old enough.")

  File "/home/you/vote.py", line 2
    if age = 18:
       ^^^^^^^^
SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

That's lesson 1's first kind of failure: found while parsing, so nothing printed. Python even guesses what you meant, and as before, it doesn't act on the guess.

Exactly one branch runs

score = 85

if score >= 90:
    print("A")
elif score >= 80:
    print("B")
else:
    print("F")

Python works down the chain, testing each condition in turn, and the first one that's true wins. Its block runs and the whole chain is finished: nothing below it is even looked at.¹ If none of them is true, the else runs. If there's no else, nothing runs, which is allowed.

Only one of the three exits on the right is ever taken. Follow a score of 85: the first test is false, so control drops down the left; the second is true, so it goes right and stops. print("F") is never reached, and neither is any test below the one that matched.

score = 95

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

C

Indentation is the syntax

In most languages the indented lines under an if are a courtesy to the reader. In Python they're how the language knows which lines the if controls. Four spaces is the convention, and it's in PEP 8 along with the naming rules from lesson 2.²

Get it wrong and you may get an IndentationError, which is the friendly outcome. The unfriendly one is a program that runs and quietly does the wrong thing. These two differ by four spaces:

temperature = 15

if temperature > 30:
    print("It's hot.")
print("Remember your coat.")

Remember your coat.

Indent that second print by four spaces and the same program, on the same input, prints nothing at all, because the line is now inside the if and the condition is false. No error either way. The whitespace is the logic.

Combining conditions

Three words join conditions together: and needs both sides true, or needs at least one, and not flips a value.

age = 25
has_ticket = True

if age >= 18 and has_ticket:
    print("Come in.")

Underneath these three words there's a mechanism, and it's more useful than the rule itself. Python stops evaluating as soon as the answer is settled. With and, the moment it meets something false the whole thing must be false, so it doesn't bother looking at the right-hand side. That's called short-circuiting, and you can build on it:

if n != 0 and total / n > 5:
    print("big")

If n is zero, the left side is false, Python stops, and the division on the right is never carried out. Swap the two around and the same line raises ZeroDivisionError, which lesson 4 will meet properly, on the first zero it meets. So the order of the two sides is doing real work.

Things that are false without a comparison

You don't have to write a comparison. Python will take any value and decide whether it counts as true, and the rule is short: empty things are false, and so is zero.³

>>> bool(0), bool(0.0), bool(""), bool([]), bool({}), bool(None)
(False, False, False, False, False, False)

Everything else is true. That lets you write this, which reads well:

name = input("Your name: ")
if not name:
    print("You didn't type anything.")

And it sets one trap that catches nearly everyone.

>>> bool(0)
False
>>> bool("0")
True

A program that has to check its input

Lesson 2 left int(input(...)) sitting there with a fault in it. If the user types anything that isn't a whole number, the conversion fails:

>>> int("seven")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    int("seven")
    ~~~^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'seven'

At your own prompt that filename may read <python-input-0> rather than <stdin>, depending on which interactive shell your Python starts. It means the same thing: the line came from you, not from a file.

ValueError is the fourth error in this course, and it means the type was right but the value wasn't: int() takes strings, and this one wasn't a number. So check before you convert:

reply = input("How many tickets? ")

if reply.isdigit():
    tickets = int(reply)
    print(f"That will be {tickets * 12} pounds.")
else:
    print("Please type a whole number.")

.isdigit() asks a string whether every character in it is a digit, and hands back a bool. Now the part that catches people:

>>> "7".isdigit()
True
>>> "-3".isdigit()
False
>>> "4.5".isdigit()
False

A minus sign isn't a digit, and neither is a full stop. So .isdigit() is right for counting tickets, where negatives are meaningless anyway, and wrong for a temperature or a bank balance.

There's one more thing it does that you'd never guess, and it matters if you're using it as a guard:

>>> "²".isdigit()
True
>>> int("²")
ValueError: invalid literal for int() with base 10: '²'

.isdigit() says yes to a handful of characters int() won't take, superscripts among them, so a guard built on it can still let a ValueError through. The strict version is .isdecimal(), whose answer is exactly what int() will accept, and it's the one to reach for when the conversion has to succeed. "7".isdecimal() is True; "-3", "4.5" and "²" are all False.

What people get wrong

Writing = where == belongs. Python catches this one for you, before anything runs, and tells you what you probably meant.

Expecting every true branch to run. In an if / elif chain, one runs at most. If you actually want two independent checks, write two separate if statements, and notice that you're choosing that.

Writing if x == True:. These two ask different questions. if x == True: asks whether x equals True; if x: asks whether x is truthy. They agree only when x is already a bool, which is why if name == True: is false for every name anyone ever types, even though if name: is true for all of them. Write if x:.

Thinking else is required. It isn't. A chain with no else simply does nothing when nothing matches, which is often what you want.

Not knowing that Python chains comparisons. if 1 < x < 10: means what it looks like it means. Most languages don't do this, so if you've written any C or Java you may not trust it. Trust it.

Practice

If you can't see why a chain picked the branch it did, put the program into Python Tutor and step through it. It shows you each test as it's evaluated.

Connections

Lesson 2 gave your programs a memory. This lesson lets them choose, and it added ValueError to the errors you can read, along with the guard that stops one happening.

Next is repetition, and it needs everything here. A while loop is an if that keeps asking, so its condition is a bool exactly like these, truthiness matters there too, and the guard you just learned is what stops a loop dividing by a count that's still zero.

Go deeper

• The Python tutorial, chapter 4, on control flow. The reference version of this lesson, plus match statements, which are worth knowing about once chains get long.
• Think Python, chapter 5, "Conditionals and Recursion", free online. Downey introduces recursion alongside conditionals, which is unusual and works better than you'd expect.
• Automate the Boring Stuff, chapter 2, free online. Sweigart spends longer than most books on flow control diagrams, which is the right instinct for this topic.

Sources

1. The Python Tutorial, chapter 4, "More Control Flow Tools", Python 3.14 documentation. if, elif, else, and the boolean operators.
2. PEP 8, Style Guide for Python Code. Four spaces per indentation level.
3. Python documentation, Built-in Types, "Truth Value Testing". The list of values that count as false.
4. All code output in this lesson was run on CPython 3.14.7 and pasted from the terminal, including the SyntaxError suggesting ==, the ValueError from int("seven"), and the three .isdigit() results.