At the end of the previous module we left the Papyrus project with its environment ready and several scripts running, and we promised that your programs would start making decisions. This lesson delivers on that promise: you'll learn to use if, elif and else so that Python runs one piece of code or another depending on which conditions hold. It's the difference between a script that always does the same thing and a program that reacts: "is The Odyssey in stock?", "is Luis a member? Then apply his discount". Without conditionals there is no business logic to speak of, so this is probably the most important lesson of the course so far.

1. The if statement: making the first decision
2. else: the alternative path
3. elif: chaining several conditions
4. Nested conditionals
5. Compound conditions with and, or and not
6. Truthiness: values that behave like True or False
7. The ternary operator: conditionals in one line

The basic structure of a conditional in Python is the if statement. Its syntax is:

Notice three fundamental details:

• The condition is any expression Python can evaluate as True or False (the booleans you saw in module 1).
• The colon (:) at the end of the if line is mandatory. Forgetting it is the most frequent syntax error when starting out.
• The indented block (4 spaces, as you already know from PEP 8) defines which statements depend on the if. In Python, indentation isn't cosmetic: it is the structure of the program.

Let's solve the first question Ana asks herself every time someone requests a book at Papyrus: is it in stock?

Output:

What exactly happened?

1. Python evaluates stock > 0. Since stock is 4, the expression gives True.
2. Because it's true, the indented block runs (the print with the availability message).
3. The last line, print("Query finished."), is not indented, so it's not part of the if: it always runs, whether there's stock or not.

If you change stock = 0 and run it again, you'll see only Query finished.: the if block is skipped entirely.

The program reaches a fork, picks a path according to the condition, and then both paths join up again.

Very often "do this if it holds" isn't enough: you also want to do something else if it doesn't. That's what else is for:

Output:

Rules for else:

• It takes no condition of its own: it runs when the if condition is false.
• It goes at the same indentation level as its if, also with a colon.
• It's optional: an if can perfectly well stand alone, as in the first example.

With if/else you guarantee that exactly one of the two blocks always runs.

What if there are more than two scenarios? Ana wants to classify each book's stock into three levels: out of stock, only a few units left, or enough stock. To chain conditions you use elif (a contraction of else if):

Output:

How Python evaluates it, in order and top to bottom:

1. stock == 0 → 8 == 0 is False. That block is skipped.
2. stock <= 3 → 8 <= 3 is False. Skipped too.
3. No condition held, so the else runs.

Key points about if/elif/else chains:

• You can add as many elif branches as you need.
• As soon as one condition gives True, its block runs and the rest of the chain is ignored, even if other conditions would also have been true. Order matters.
• The final else is optional, but it's usually a good idea to include it as a "default case".

That second point deserves an example. Watch what happens if we order the conditions badly:

With stock = 0, the first condition (0 <= 3) is already true, so the "OUT OF STOCK" message will never be shown. Practical rule: put the most specific conditions first and leave the more general ones for the end.

An if block can, in turn, contain another if. That's what we call nesting, and it's used for decisions that depend on a previous decision. At Papyrus: first we check whether there's stock and, only if there is, we check whether the customer is a member so we can apply the discount.

Output:

Look at the indentation: the if is_member: is indented 4 spaces (inside the first if), and its inner blocks are at 8 spaces. Each level of nesting adds 4 spaces.

Style tip: two levels of nesting read well; three start to hurt; four or more usually mean the code needs reorganizing (often with compound conditions, which we'll see next, or with functions, which you'll see in module 3).

You already know the logical operators from module 1. This is precisely their big moment: combining several checks into a single condition.

With and we can rewrite the previous example without nesting, when we only care about one specific case:

And with or, Ana can spot books that need her attention for either of two reasons:

Two important details about logical operators in conditions:

• Short-circuit evaluation: in a and b, if a is False, Python doesn't even evaluate b (the result can no longer be True). In a or b, if a is True, it doesn't evaluate b. This is exploited to write safe conditions, such as if stock > 0 and 10 / stock < 3: — the division never runs if stock is 0.
• Chained comparisons: Python lets you write if 1 <= stock <= 3: instead of if stock >= 1 and stock <= 3:. Both are equivalent, but the first is more readable and very idiomatic.

When a compound condition mixes and and or, use parentheses to make the intent clear (remember that and has priority over or):

So far our conditions were explicit comparisons (stock > 0). But Python lets you put any value as a condition, and it will convert it to a boolean automatically. This implicit conversion is called truthiness.

The rule is easy to remember: empty and null things are false; everything else is true. These are the most common falsy values (values that evaluate to False):

Everything else is truthy: 1, -3, 0.01, "hello", " " (a string with a space in it isn't empty!), and so on.

You can check it in the REPL with bool():

What is it good for in practice? Writing more natural conditions. These two versions are equivalent, and the second is the idiomatic one in Python:

And it's very useful with input(), which as you'll remember always returns str. If the user presses Enter without typing anything, it returns the empty string "", which is falsy:

Here not name is True when name is empty, so we assign a default value. This pattern (checking whether an input is empty) comes up constantly in real programs.

Nuance: use truthiness when the natural question is "is there anything here?" (is there text?, are there units?). If the question is about a specific value ("is the stock exactly 0?", "is the answer 'y'?"), the explicit comparison (==) communicates the intent better.

When all an if/else does is choose between two values, Python offers a compact form called a conditional expression or ternary operator:

Compare the classic version with the ternary one to work out Luis's price:

It also shines inside f-strings, for example on the Papyrus receipt:

Rules for using the ternary:

• It's an expression: it produces a value, so you can assign it, print it or pass it to a function. A regular if is a statement and produces no value.
• It reads "A if condition, otherwise B", which is almost natural language.
• Use it only for simple choices between two values. If you need to run several statements, or nest ternaries inside ternaries, go back to the classic if/else: readability rules.

• Forgetting the colon at the end of if, elif or else produces a SyntaxError. It's every beginner's number-one slip; check it before anything else.
• Confusing = with ==: if stock = 0: is a syntax error. = assigns, == compares. Python protects you here by refusing to run it.
• Inconsistent indentation: mixing 4 spaces with tabs or with 3 spaces causes an IndentationError. Configure your editor (VS Code does it by default) to insert 4 spaces when you press Tab.
• Ordering the elif branches badly: as you saw, if a broad condition comes before a specific one, the specific one will never run. Order from most specific to most general.
• Comparing floats with ==: because of the decimal imprecision we saw in module 1, 0.1 + 0.2 == 0.3 gives False. For money in conditionals, compare with a margin: abs(total - expected) < 0.001.
• if is_member == True: works, but it's redundant: is_member is already a boolean. Write if is_member: and, for the opposite case, if not is_member:.
• Tip: when a compound condition becomes hard to read, store it in a variable with a descriptive name: can_buy = stock > 0 and is_member and then if can_buy:. The code documents itself.

Write a script stock_level.py that, given the variables title and stock, prints:

• "OUT OF STOCK — order urgently" if the stock is 0.
• "Low stock — restock soon" if it's between 1 and 3 (inclusive).
• "Stock OK" if it's between 4 and 10.
• "Excess stock — don't order more" if it's greater than 10.

Try it with the three books in the catalog: The Odyssey (4), Hamlet (6) and Don Quixote (8).

Extend member_sale.py: given the variables price, is_member and stock, the script must:

1. If there's no stock, print "Sale not possible: no stock" and nothing else.
2. If there is stock, calculate the price with BOOK_VAT = 0.04 included.
3. Additionally apply MEMBER_DISCOUNT = 0.05 to the base price only if the customer is a member (the discount is applied before VAT).
4. Print the final price with two decimals.

Check that for Don Quixote (15.90 EUR) bought by Luis (a member) the result is 15.71 EUR.

In book_card.py we promised to validate the input. Take the first step: use input() to ask for a book's title and its price. Using truthiness and a ternary:

• If the title is empty, print "Error: the title is required".
• Otherwise, convert the price to float and print, in a single f-string with a ternary, "<title>: budget" if it costs less than 12 EUR or "<title>: premium" otherwise.

Solution 1:

Notice that you don't need to write 1 <= stock <= 3 in the second case: if we reach that elif, we already know stock isn't 0, so stock <= 3 is enough. Each branch can rely on the previous ones having failed. All three catalog books fall into "Stock OK".

Solution 2:

Step-by-step calculation: 15.90 × 0.95 = 15.105 (member discount) and 15.105 × 1.04 = 15.7092, which the f-string rounds to 15.71 EUR. The ternary resolves the choice of base price in one line.

Solution 3:

not title is True when the user presses Enter without typing (empty string, falsy). The ternary goes inside the f-string, between braces, because it's an expression and produces a value. Note: if the user types a non-numeric price, float() will fail with a ValueError; we'll learn to handle that gracefully in module 7.

Your programs can now decide. You've learned the if statement together with its companions elif and else, how to nest decisions when one depends on another, how to combine checks with and/or/not (including short-circuiting), how to take advantage of the truthiness of empty values, and how to condense simple choices with the ternary operator. Papyrus can now answer its two essential business questions: whether there's stock and whether the member discount applies.

But we're still deciding book by book, with loose variables. Ana has a whole catalog, and checking the stock of every title by copy-pasting ifs doesn't scale. What we need is to repeat an operation over many items, and that's exactly what the next lesson is about: the for and while loops, with which we'll walk through the entire Papyrus catalog and add up the day's takings in just a few lines.