How does Python decide which branch of an if/elif/else chain executes?

### The rule in one line An `if` / `elif` / `else` chain is **one compound statement**, and Python runs **at most one** of its blocks: it evaluates the conditions in the order they are written and jumps into the first block whose condition is truthy, skipping everything else. ```python if a: ... # runs only if a is truthy elif b: ... # runs only if a is falsy AND b is truthy elif c: ... # runs only if a and b are falsy AND c is truthy else: ... # runs only if a, b and c are all falsy ``` There is no scoring, no best-match, no fall-through into the next block the way a C `switch` falls through without `break`. First match wins, then the statement is finished. ### Evaluation is lazy, and that is observable The conditions are not all computed up front. Python evaluates one, decides, and only evaluates the next if the current one was falsy. So a condition further down the chain can be an expression that is expensive, that has a side effect, or that would raise — and none of that happens once an earlier branch has matched. ```python def positive(n): print("evaluated positive()") return n > 0 x = 5 if x > 1: result = "gt1" elif positive(x): # never called: the first condition already won result = "positive" ``` This is the same short-circuit discipline you get from `and` and `or`, applied at statement level. It is a feature: you can safely write `if obj is None: ... elif obj.ready(): ...` because the attribute access is only reached when `obj` is not `None`. ### Order is precedence Because the first truthy condition wins, **the order of the branches is part of the program's meaning** whenever two conditions can both be true for the same input. A chain of numeric thresholds is the classic case: `score >= 90` must be tested before `score >= 60`, because a score of 95 satisfies both and only the first one reached will run. Reordering an `elif` is therefore a semantic edit, never a cosmetic one — treat it in review the way you would treat changing an operator. When the conditions are genuinely mutually exclusive (`status == "new"`, `status == "paid"`, `status == "void"`), order does not affect correctness, only readability and, marginally, how many comparisons run for the common case. ### `elif` versus separate `if` statements This is the distinction interviewers actually probe. A chain expresses *choose one*; a sequence of independent `if` statements expresses *apply each that fits*. ```python n = 12 tags = [] if n % 2 == 0: tags.append("even") if n % 3 == 0: tags.append("multiple of 3") # tags == ['even', 'multiple of 3'] -- both ran ``` Swap the second `if` for an `elif` and you get `['even']` only. Bugs in both directions are common: an accumulation loop written with `elif` silently drops labels, and a decision written with separate `if`s lets a later branch overwrite an earlier one's result. `elif` is also not merely cosmetic sugar for a nested `else: if ...`. It is semantically identical, but it keeps the whole chain at one indentation level, which is exactly what stops a five-way decision from becoming a five-deep staircase. ### Conditions are truthiness tests, not boolean tests The condition may be any expression. Python asks the object whether it is truthy, so `if items:` matches a non-empty list and `elif items is None:` after it would be dead code for the empty-list case. You do not need `== True`, and writing it narrows the test in ways that surprise people. ### No `else` is legal The `else` clause is optional. Without it, an input that matches nothing simply falls out of the statement and execution continues on the next line — no error, no diagnostic. In a function whose branches each `return`, that fall-through means the function returns `None` implicitly, which is a common source of a failure that surfaces far from the chain that caused it. ### What the interviewer is listening for At junior level: top to bottom, first match, at most one block, `else` is the catch-all. One layer down: laziness (later conditions may never be evaluated), order as precedence, and the `elif`-versus-separate-`if` distinction stated crisply with an example. Those three points are the whole answer.