Control Flow and Conditionals

Every program so far in the Python for Beginners series has run from top to bottom. Conditions change that: if lets a program pick a path, and the rules Python uses to decide what counts as true are shorter — and stricter — than JavaScript’. This chapter covers if, elif and else, the truthiness table, chained conditions, the conditional expression, the three boolean operators and how they short-circuit, and the difference between is and ==.

if, elif and else

A conditional is a keyword, a colon and an indented block. Python evaluates the conditions in order and runs the first branch whose test is true; everything after it is skipped. else is the fallback and takes no condition of its own:

score = 78

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

print("Score:", score, "Grade:", grade)

Expected output:

Score: 78 Grade: C

Order matters: the tests are mutually exclusive only because they descend. Put the score >= 70 branch first and every passing score would sort into “C”. Because only one branch can run, Python also guarantees a single assignment — but nothing forces you to write an else, and a condition with no matching branch simply leaves the variables untouched.

Truthiness: what counts as false

Conditions do not need a bool; Python asks the value itself. Almost everything is truthy, and a small, fixed list of values is falsy. Memorise the list once and you never have to look anything up:

• False and None — the explicit boolean and the “no value here” object.
• Any numeric zero: 0, 0.0, 0j — zeros only, never a near-zero.
• Empty text and containers: "", [], {} and set() — note {} on its own is an empty dict.
• Everything else is truthy — including "0", [0] and {0: 0}.

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

Expected output:

False False False False False False False False

[0] is truthy because the list is not empty — truthiness asks about structure, not about the values inside. The same rule powers the shortcut name = user_input or "anonymous": or returns its first truthy operand, so an empty string falls through to the default.

Chained comparisons in conditions

Chapter 5 introduced 0 <= score <= 100; in an if it is where it belongs. The chain is sugar for 0 <= score and score <= 100, evaluated with score read once and in order — the second test is only reached if the first passed:

age = 17

if 0 <= age < 18:
    print("junior ticket")
if 12 <= age <= 65:
    print("standard ticket")

Expected output:

junior ticket
standard ticket

The conditional expression (ternary)

Python has no condition ? a : b, but it has an expression form that fits on one line: value if condition else value. Use it for short assignments, never for statements — a multi-branch decision belongs in an if:

age = 17
status = "adult" if age >= 18 else "minor"
print(status)

Expected output:

minor

and, or, not — and short-circuiting

Boolean operators in Python are not symbol-shaped, and they are lazy. and stops as soon as an operand is falsy; or stops as soon as one is truthy — the right-hand side is never evaluated unless it is needed:

x = 10
print(x > 5 and x < 20)
print(not x)

y = 0
left = y and print("and evaluates this")
print("left =", left)

z = 5
right = z or print("or evaluates this")
print("right =", right)

Expected output:

True
False
left = 0
right = 5

Neither print() inside the expressions ran — the first line of each pair returned before reaching them. Note also what is returned: and and or hand back one of their operands, not a boolean. y and … returned 0 (the falsy left operand), z or … returned 5. That is how x or "default" works, and it is the same idea as JavaScript’s || and ?? — except Python insists on real booleans nowhere and evaluates truthiness with the table above. not is the only operator that always produces a bool.

Short-circuiting is also a safety tool: if user is not None and user["name"] never indexes None, because the second half cannot run.

Identity: is versus ==

== asks whether two values are equal; is asks whether two names point at the same object. For immutable values the difference rarely shows, but it decides the truth about containers:

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)
print(a is b)

Expected output:

True
False

The two lists hold equal values but are separate objects, so is correctly says no. Two rules cover everyday use: compare values with ==, and test for a missing value with is None (or is not None) — never with == None, and never with x is True, which tests identity against one particular bool object instead of asking whether the value is truthy.

A worked decision program

Conditions, chaining, and and fallbacks in one short program. Predict the output before you run it:

age = 15
is_student = True

if age < 12:
    ticket = 8
elif age < 18:
    ticket = 10
else:
    ticket = 14

if is_student and ticket > 5:
    ticket = ticket - 4

if ticket <= 10:
    message = "Budget-friendly"
elif ticket <= 15:
    message = "Standard price"
else:
    message = "Premium event"

print("Ticket:", ticket)
print("Message:", message)

Expected output:

Ticket: 6
Message: Budget-friendly

Trace it: age = 15 meets the second branch and sets ticket = 10; the student discount applies because is_student is true and the ticket is above 5, giving 6; and 6 lands in the first range of the second decision. Three if statements, one value flowing through them — this is the shape of most business logic you will ever write.

Common mistakes

• Using = instead of == — an assignment is not a condition; Python flags if score = 78: as a SyntaxError before anything runs.
• Assuming elif order does not matter — the first true branch wins, so overlapping ranges must be written from the most specific to the most general.
• Testing truthiness when you meant None — if not value: also rejects 0 and ""; use if value is None: when absence is the only thing you mean.
• Porting JavaScript’s truthy rules — "false" and "0" are truthy here too (they are non-empty strings), while 0 is falsy in both languages.
• Writing if x == True: — it fails for 1 and works for True by accident; write if x: or if x is True: deliberately.

Practice checklist

1. Extend the grade program to emit "A+" for 97 and above and "incomplete" for scores below 40.
2. Write out the eight falsy values from memory, run bool() on each, and add three truthy values that beginners guess wrongly.
3. Rewrite status = "adult" if age >= 18 else "minor" as an if block, then convert a three-branch if back into a conditional expression.
4. Prove short-circuiting: add a second condition that would raise an error if evaluated, and show that and never reaches it.
5. Build two lists with equal contents and print == and is for them; then replace every == None in your notes with is None.

What's next?

The program can now decide between paths, but only once per run. Next you make it repeat — Loops and Iteration.