{"title":"if-else-elif Statements","description":"","content":"Most useful programs need to make decisions: charge shipping if the cart is below a threshold, mark an order as eligible for a discount, refuse to add an item if it's out of stock. The `if` statement is how Python expresses those decisions. This lesson covers the full shape of conditional branching, the way Python decides which branch to run, and the small set of mistakes that bite almost every beginner.\n\n---\n\n# The `if` Statement\n\nAn `if` statement runs a block of code only when a condition is true. The shape is always the same: the keyword `if`, then an expression that produces `True` or `False`, then a colon, then an indented block.\n\n\n```python\ncart_total = 75\n\nif cart_total >= 50:\n print(\"You qualify for free shipping.\")\n\nprint(\"Done.\")\n```\n\n\nThree things in that snippet are doing real work, and skipping any of them produces an error. The colon at the end of the `if` line tells Python \"a block follows\". The indentation under it (four spaces, by convention) marks which lines belong to the block. The line `print(\"Done.\")` is back at the outer indentation, so it runs whether the condition is true or false.\n\nIf you forget the colon, Python rejects the file with a `SyntaxError`:\n\n\n```python\nif cart_total >= 50\n print(\"Free shipping!\")\n```\n\n\nIf you forget the indentation, Python complains too, because the block under an `if` cannot be empty:\n\n\n```python\nif cart_total >= 50:\nprint(\"Free shipping!\")\n```\n\n\nPython uses indentation to define structure, where most other languages use braces. Whatever indentation width you pick for the first line of a block, every line in that block must use exactly the same width. Mixing tabs and spaces is the classic way to break this and get a confusing `IndentationError`. Pick spaces (PEP 8 recommends four), set your editor to insert spaces when you press Tab, and you'll never see the error.\n\nThe block under an `if` is sometimes called the **suite**. It can contain one statement or many:\n\n\n```python\ncart_total = 120\n\nif cart_total >= 100:\n discount = cart_total * 0.10\n final_total = cart_total - discount\n print(f\"Discount applied: ${discount:.2f}\")\n print(f\"You pay: ${final_total:.2f}\")\n```\n\n\nAll four lines belong to the same block because they share the same indentation. The moment a line dedents back to the outer level, the block ends.\n\n---\n\n# Adding an `else` Branch\n\n`if` on its own handles \"do this when the condition is true\". Most decisions also need a \"do this otherwise\" branch. That's what `else` is for.\n\n\n```python\nstock = 0\n\nif stock > 0:\n print(\"Add to cart.\")\nelse:\n print(\"Out of stock.\")\n```\n\n\nThe `else` keyword sits at the same indentation as its `if`, gets its own colon, and introduces another indented block. Exactly one of the two blocks runs, never both, never neither. The condition decides which one.\n\nYou can read `if` / `else` out loud almost like English: \"If the stock is greater than zero, add to cart; otherwise, mark it out of stock.\" That's a good check for whether your condition makes sense. If reading it out loud sounds backwards, the condition probably is backwards.\n\nA common pattern is to compute one of two values based on a condition:\n\n\n```python\nitems_in_cart = 3\nshipping = 0 if items_in_cart >= 5 else 4.99\n\nprint(f\"Shipping: ${shipping:.2f}\")\n```\n\n\nThat one-line form is a **ternary expression**. For now, use the full `if` / `else` block whenever the body has more than a single value to compute, because it stays readable as logic grows.\n\n---\n\n# The `elif` Chain\n\nMany decisions have more than two outcomes. Order status, for example, can be `placed`, `shipped`, `delivered`, or `cancelled`, and each value should produce a different message. Stacking nested `if` statements works but reads badly. Python gives you `elif` (short for \"else if\") for this exact pattern.\n\n\n```python\nstatus = \"shipped\"\n\nif status == \"placed\":\n message = \"Your order has been received.\"\nelif status == \"shipped\":\n message = \"Your order is on the way.\"\nelif status == \"delivered\":\n message = \"Your order has arrived.\"\nelif status == \"cancelled\":\n message = \"Your order was cancelled.\"\nelse:\n message = \"Unknown order status.\"\n\nprint(message)\n```\n\n\nYou can chain as many `elif` branches as you need, and the trailing `else` is optional. Without an `else`, none of the branches may run, and execution simply continues past the chain.\n\nHere's what's actually happening when Python sees this chain:\n\n\n```mermaid\nflowchart TD\n A[Start]:::cyan --> B{status == 'placed'?}:::orange\n B -->|True| C[Run placed branch]:::green\n B -->|False| D{status == 'shipped'?}:::orange\n D -->|True| E[Run shipped branch]:::green\n D -->|False| F{status == 'delivered'?}:::orange\n F -->|True| G[Run delivered branch]:::green\n F -->|False| H{status == 'cancelled'?}:::orange\n H -->|True| I[Run cancelled branch]:::green\n H -->|False| J[Run else branch]:::teal\n C --> K[Continue after chain]:::cyan\n E --> K\n G --> K\n I --> K\n J --> K\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nTwo important things are visible in that flow. Python checks conditions **top to bottom**, and it stops at the **first one that's true**. After running the matching branch, it skips every remaining `elif` and the `else`, then continues with whatever comes after the chain. No second branch runs, even if its condition would also have been true.\n\nThat ordering matters when ranges overlap. Watch what happens with a poorly ordered discount tier:\n\n\n```python\ncart_total = 250\n\nif cart_total >= 50:\n discount = 0.05\nelif cart_total >= 100:\n discount = 0.10\nelif cart_total >= 200:\n discount = 0.15\nelse:\n discount = 0\n\nprint(f\"Discount: {discount * 100:.0f}%\")\n```\n\n\nA $250 cart should have qualified for the 15% tier, but the customer got 5%. The first branch matched (because $250 is greater than $50), and Python stopped there. The fix is to order the checks from most specific to least specific:\n\n\n```python\ncart_total = 250\n\nif cart_total >= 200:\n discount = 0.15\nelif cart_total >= 100:\n discount = 0.10\nelif cart_total >= 50:\n discount = 0.05\nelse:\n discount = 0\n\nprint(f\"Discount: {discount * 100:.0f}%\")\n```\n\n\nNow the `>= 200` branch fires first, the rest are skipped, and the customer gets the right tier. The general rule for chained ranges: put the tightest condition at the top.\n\n---\n\n# Truthy and Falsy Conditions\n\nThe condition in an `if` doesn't have to be a real `True` or `False`. Python accepts any value and asks: \"does this count as true?\". Every value in the language has an answer. The values that count as false are called **falsy**, and the rest are **truthy**.\n\nThe full list of falsy values is short:\n\n- `False`\n- `None`\n- Zero of any numeric type: `0`, `0.0`, `0j`\n- Empty containers: `\"\"`, `[]`, `{}`, `()`, `set()`\n- Anything that defines `__bool__` to return `False` or `__len__` to return `0`\n\nEverything else is truthy. That includes negative numbers, the string `\"False\"`, the list `[0]`, and any non-empty container.\n\n\n```python\nprint(bool(0))\nprint(bool(\"\"))\nprint(bool([]))\nprint(bool(None))\nprint(bool(\"anything\"))\nprint(bool([0]))\nprint(bool(-5))\n```\n\n\nThe string `\"anything\"` is truthy because it isn't empty. The list `[0]` is truthy because it has one element, even though that element is itself falsy. `-5` is truthy because the only falsy number is zero.\n\nThis rule turns \"is this collection non-empty?\" into a one-liner. Compare the verbose version with the Pythonic version:\n\n\n```python\ncart = [\"Wireless Mouse\", \"USB Cable\"]\n\n# Verbose\nif len(cart) > 0:\n print(\"You have items in your cart.\")\n\n# Pythonic\nif cart:\n print(\"You have items in your cart.\")\n```\n\n\nBoth work, both are correct, and both produce identical output. The second form is what experienced Python developers write because it reads naturally and works for every container type without thinking about which one. If `cart` is an empty list, an empty tuple, or an empty set, `if cart:` is `False`. Any item, of any type, makes it `True`.\n\nThe same idiom shows up everywhere:\n\n\n```python\ncustomer_name = \"\"\ndiscount_code = None\nwishlist = []\nratings = [4, 5, 3]\n\nif not customer_name:\n print(\"Please enter your name.\")\n\nif discount_code:\n print(f\"Applying code: {discount_code}\")\n\nif not wishlist:\n print(\"Your wishlist is empty.\")\n\nif ratings:\n average = sum(ratings) / len(ratings)\n print(f\"Average rating: {average:.1f}\")\n```\n\n\nEach `if` reads almost like English: \"if no customer name\", \"if a discount code is set\", \"if the wishlist is empty\", \"if there are ratings\". No need to write `len(...) > 0` or `!= None` or `!= \"\"` for any of them. Python's truthiness rules cover all four.\n\nThere is one place where you need to be careful with this style: distinguishing \"no value\" from \"the value is zero\". If `discount` could legitimately be `0`, then `if discount:` treats that as missing, which is wrong. In that case, compare explicitly: `if discount is not None:`.\n\n\n```python\ndiscount = 0\n\nif discount:\n print(\"Applying discount.\")\nelse:\n print(\"No discount value provided.\")\n```\n\n\nThe customer's discount is `0`, which is a real value, but `if discount:` treats it as falsy and the wrong branch runs. Use `if discount is not None:` when zero is meaningful.\n\n---\n\n# Combining Conditions\n\nReal decisions usually depend on more than one fact. The Boolean operators `and`, `or`, and `not` are what tie multiple conditions together inside an `if`.\n\nThe key behavior is **short-circuit evaluation**. `and` stops at the first falsy operand, `or` stops at the first truthy one. That's not just a performance optimization. It also lets you safely guard a check that would otherwise crash:\n\n\n```python\ndiscount_code = None\n\nif discount_code and discount_code.startswith(\"SAVE\"):\n print(\"Valid discount code.\")\nelse:\n print(\"No valid code applied.\")\n```\n\n\nIf `discount_code` is `None`, calling `.startswith` on it would raise an `AttributeError`. The `and` operator never gets that far: the left side is `None` (falsy), so the right side is never evaluated. Order matters here. Reverse the operands and the same code crashes:\n\n\n```python\ndiscount_code = None\n\nif discount_code.startswith(\"SAVE\") and discount_code:\n print(\"Valid discount code.\")\n```\n\n\nAlways put the cheap, safety-checking condition first when you're guarding against a value that might not exist.\n\n`or` works the same way, just with the test flipped: it stops at the first truthy operand. That makes it the natural choice for \"any of these is enough\":\n\n\n```python\ncart_total = 35\nis_member = True\nhas_promo = False\n\nif cart_total >= 50 or is_member or has_promo:\n print(\"Free shipping applied.\")\nelse:\n print(\"Standard shipping rates apply.\")\n```\n\n\nThe cart total alone wouldn't qualify, but the customer is a member, so the second operand is true and the rest of the chain is skipped. Three conditions, any of which would trigger free shipping, expressed in one readable line.\n\n`not` flips a single condition. The two forms below mean the same thing, and the second one is usually nicer:\n\n\n```python\ncart = []\n\n# Awkward\nif cart == []:\n print(\"Cart is empty.\")\n\n# Cleaner\nif not cart:\n print(\"Cart is empty.\")\n```\n\n\n`not cart` reads as \"if there's nothing in the cart\" and works for any empty container. The `== []` form only handles lists, and you'd have to write a different version for empty strings, sets, or dictionaries.\n\n### Chained Comparisons in Conditions\n\nChained comparisons are especially useful inside `if` statements because they map cleanly to range checks:\n\n\n```python\ndiscount = 0.25\n\nif 0 < discount < 1:\n print(f\"Applying {discount * 100:.0f}% discount.\")\nelse:\n print(\"Discount out of valid range.\")\n```\n\n\n`0 < discount < 1` reads exactly like the math notation and means `0 < discount and discount < 1`. The variable `discount` is evaluated only once. Use this form for any \"is this value in a range?\" check; it's shorter and clearer than two separate comparisons joined by `and`.\n\n\n```python\nrating = 4.5\n\nif 1 <= rating <= 5:\n print(\"Valid rating.\")\nelse:\n print(\"Rating must be between 1 and 5.\")\n```\n\n\n---\n\n# Nested `if` vs Flat `elif` Chains\n\nWhen one decision depends on another, beginners often reach for a nested `if`. Sometimes that's the right call. More often, the same logic reads better as a flat chain or a guard-clause style.\n\nHere's a nested version that decides what message to show on a product page based on stock and price:\n\n\n```python\nstock = 4\nprice = 30\n\nif stock > 0:\n if stock < 5:\n if price < 50:\n message = \"Almost gone, low price!\"\n else:\n message = \"Almost gone, premium item.\"\n else:\n message = \"In stock.\"\nelse:\n message = \"Out of stock.\"\n\nprint(message)\n```\n\n\nIt works, but the deep indentation makes the logic hard to follow. Each level of nesting adds visual weight without adding clarity. Flatten it by combining the conditions:\n\n\n```python\nstock = 4\nprice = 30\n\nif stock == 0:\n message = \"Out of stock.\"\nelif stock < 5 and price < 50:\n message = \"Almost gone, low price!\"\nelif stock < 5:\n message = \"Almost gone, premium item.\"\nelse:\n message = \"In stock.\"\n\nprint(message)\n```\n\n\nSame behavior, much easier to scan. Each branch states its full condition on one line, and there's no nesting to track in your head.\n\nAnother pattern that often beats nesting is the **guard clause**: handle the special cases up front and bail out, then write the main logic at the outer level. Inside a function, this usually means returning early. Outside a function, it means assigning a value and using a chain that handles the easy rejections first.\n\n\n```python\nstock = 0\n\nif stock <= 0:\n message = \"Out of stock.\"\nelif stock < 5:\n message = \"Almost gone.\"\nelse:\n message = \"In stock.\"\n\nprint(message)\n```\n\n\nThe \"out of stock\" case is the most restrictive, so it goes first. After that, the rest of the chain only deals with the \"in stock\" case in two flavors. The result is a single linear flow of branches with no nesting at all.\n\nNesting is fine when the inner decision is genuinely meaningful only when the outer condition holds, and especially when the inner decision has its own multi-branch chain. The rule of thumb: if you can replace nesting with `and` / `or` and still read the code aloud naturally, flatten it.\n\n---\n\n# Common Mistakes\n\nA handful of bugs come up over and over with `if` statements. Each one is small, each one feels obvious in hindsight, and each one will catch you at some point.\n\n### Using `=` Instead of `==`\n\nIn an `if` condition, you want to **compare** with `==`, not assign with `=`. Python catches this and raises a `SyntaxError`, which is helpful but still surprises people coming from languages where the same mistake silently compiles.\n\n\n```python\nstatus = \"shipped\"\n\nif status = \"shipped\":\n print(\"On the way.\")\n```\n\n\nThe fix is to double up the equals sign:\n\n\n```python\nstatus = \"shipped\"\n\nif status == \"shipped\":\n print(\"On the way.\")\n```\n\n\n### Comparing Against Multiple Values the Wrong Way\n\nThis one is sneakier because it doesn't raise an error. The bug runs cleanly and produces the wrong answer.\n\n**What's wrong with this code?**\n\n\n```python\nstatus = \"placed\"\n\nif status == \"shipped\" or \"delivered\":\n print(\"Your order is in transit or has arrived.\")\nelse:\n print(\"Your order is still being processed.\")\n```\n\n\nThe order has status `\"placed\"`, so the message should say it's still being processed. Instead, it falsely claims the order is in transit. The bug is in the condition.\n\n`status == \"shipped\" or \"delivered\"` parses as `(status == \"shipped\") or \"delivered\"`. The first half is `False`, so `or` evaluates the second half, which is the string `\"delivered\"`. Non-empty strings are truthy, so the whole expression is truthy, and the wrong branch runs. The string `\"delivered\"` is **not** being compared against `status` at all; it's just sitting there as a standalone value.\n\nThe fix is to compare each value explicitly, or use `in` against a collection of accepted values:\n\n\n```python\nstatus = \"placed\"\n\n# Verbose fix\nif status == \"shipped\" or status == \"delivered\":\n print(\"Your order is in transit or has arrived.\")\nelse:\n print(\"Your order is still being processed.\")\n\n# Pythonic fix\nif status in (\"shipped\", \"delivered\"):\n print(\"Your order is in transit or has arrived.\")\nelse:\n print(\"Your order is still being processed.\")\n```\n\n\nThe `in` form is shorter, scales to as many values as you want, and avoids the trap entirely. Reach for it whenever you're checking \"is this value one of these few options?\".\n\n### Forgetting That `if items:` Is the Pythonic Empty Check\n\nA long-form check like `if len(cart) > 0:` works correctly, but it's noisier than necessary. Worse, beginners sometimes write `if cart != None and cart != [] and len(cart) > 0:`, which over-checks the same thing three different ways.\n\n\n```python\ncart = [\"Wireless Mouse\"]\n\n# Over-checked\nif cart != None and cart != [] and len(cart) > 0:\n print(\"Items in cart.\")\n\n# Pythonic\nif cart:\n print(\"Items in cart.\")\n```\n\n\nBoth versions print the same thing, but the second one is much easier to read and works for every container type. Lean on Python's truthiness rules.\n\n### Comparing Floats With `==`\n\nFloating-point arithmetic is approximate, so two values that look equal on paper might not be equal in memory.\n\n\n```python\ntotal = 0.1 + 0.2\n\nif total == 0.3:\n print(\"Exact match.\")\nelse:\n print(f\"No match: total is {total!r}\")\n```\n\n\n`0.1 + 0.2` doesn't produce exactly `0.3` in binary floating point. For prices and totals where small rounding errors matter, either round before comparing or use `math.isclose` for tolerance. The Numbers section covered this in detail; the takeaway here is just to remember it inside `if` conditions.\n\n### Dangling `else` After an `elif` Chain\n\nThe `else` at the end of an `if` / `elif` chain attaches to the **whole chain**, not to any specific `elif`. That's usually what you want, but it's easy to forget when you read the code top-to-bottom.\n\n\n```python\nstatus = \"cancelled\"\n\nif status == \"placed\":\n print(\"Order received.\")\nelif status == \"shipped\":\n print(\"On the way.\")\nelif status == \"delivered\":\n print(\"Arrived.\")\nelse:\n print(\"Status unknown.\")\n```\n\n\nIf `status` were `\"cancelled\"` and you expected the `else` to handle that as an \"unknown\" case, congratulations, that's exactly what it does. But if you intended `else` to fire only when `status == \"delivered\"` was false (and the rest had matched), you've misread the structure. Each `elif` is a fresh top-level test against the original condition, and the `else` runs only when none of them matched.\n\nWhen in doubt, list every value you care about explicitly and let the `else` catch only the genuine unknowns. That makes the intent obvious to anyone reading the chain.","pageType":"python"}

if-else-elif Statements

Get Premium