Python if-elif-else – The Falsy Integer $50k Bug

Conditional logic is the first place where programs become interesting — where they make decisions. Python's if-elif-else syntax is clean and readable, but there are a few specifics that trip up people coming from other languages.

The main things to get right: truthy and falsy values (Python is more permissive than most languages about what counts as True), the elif keyword (not else if), and the ternary expression syntax which is the reverse of most languages.

Here's the thing most tutorials skip: the subtle production bugs that come from treating falsy values as errors. You'll write if user_input: and it'll silently skip valid input like 0 or an empty string. In real systems, that kind of shortcut costs you hours of debugging.

How Python's if-elif-else Actually Evaluates Conditions

Python's if-elif-else is a control structure that evaluates a sequence of boolean expressions in order, executing the first branch whose condition is truthy and skipping the rest. The core mechanic is short-circuit evaluation: once a condition matches, the entire chain terminates — no subsequent elif or else runs. This is not a switch statement; it's a linear, top-down scan with O(n) worst-case time where n is the number of branches.

In practice, each condition is evaluated in the enclosing scope at runtime. Python treats any object as truthy or falsy: None, 0, empty collections, and False are falsy; everything else is truthy. This matters because a condition like if value: will silently treat 0 as false, which has caused production bugs — including a $50k incident where a valid integer 0 was misinterpreted as missing data.

Use if-elif-else when you have mutually exclusive conditions that must be checked in a specific priority order. For simple value dispatch, prefer dictionaries or match-case (Python 3.10+) for clarity and O(1) lookup. Reserve elif chains for complex, order-dependent logic where readability outweighs the linear scan cost.

Basic if-elif-else

The simplest branching constructs. Python executes top-down: the first condition that evaluates to True triggers its block, then the rest of the chain is skipped. Indentation must be consistent — 4 spaces per PEP 8.

# Package: io.thecodeforge.python.control_flow

score = 73

if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
else:
    grade = 'F'

print(f'Score {score} → Grade {grade}')  # Score 73 → Grade C

# Conditions are checked top to bottom — first True wins
# Once a branch executes, the rest are skipped

Truthy and Falsy Values

Python evaluates any object in a boolean context. Knowing what is falsy saves you from writing verbose comparisons. But beware: the convenience of if x: can hide logical errors when falsy values are valid inputs.

# Falsy values — evaluate to False in a boolean context
falsy_examples = [
    False, 0, 0.0, 0j,       # false booleans and zeros
    '', [], {}, set(), (),    # empty sequences and collections
    None,                     # the None singleton
]

for val in falsy_examples:
    if not val:
        print(f'{repr(val):10} is falsy')

# In practice:
name = input('Enter name: ')  # imagine user entered ''
if name:  # cleaner than: if name != ''
    print(f'Hello, {name}')
else:
    print('No name provided')

# Common pitfall: 0 is falsy
count = 0
if count:  # This is False — but count is a valid value!
    print('Has items')
# Better:
if count is not None:  # only check for missing, not zero

Ternary Expression

Python's ternary is the reverse of most languages — condition comes in the middle, not at the start. It's a one-liner, but readability plummets if you chain them. Reserve it for single, obvious conditions.

age = 20

# Ternary: value_if_true if condition else value_if_false
status = 'adult' if age >= 18 else 'minor'
print(status)  # adult

# Common uses
temperature = -5
description = 'freezing' if temperature < 0 else 'warm' if temperature < 20 else 'hot'
print(description)  # freezing

# Conditional assignment (also works, but less expressive)
max_val = a if a > b else b  # same as max(a, b)

# Do NOT use for complex logic — readability drops fast
# This is too much for one line:
# result = 'a' if x > 0 else 'b' if x < 0 else 'c' if x == 0 else 'd'

match-case — Python 3.10+

Python 3.10 added structural pattern matching. It is more powerful than a chain of elif — it can match on structure, not just equality. Use it when you'd otherwise write a long elif chain on a single value or when you need to destructure nested data.

def http_status(code: int) -> str:
    match code:
        case 200: return 'OK'
        case 201: return 'Created'
        case 400: return 'Bad Request'
        case 401 | 403: return 'Auth error'  # multiple values with |
        case 404: return 'Not Found'
        case 500: return 'Internal Server Error'
        case _: return f'Unknown status: {code}'  # default

print(http_status(200))  # OK
print(http_status(403))  # Auth error
print(http_status(999))  # Unknown status: 999

# Structural matching on tuples
def describe_point(point):
    match point:
        case (0, 0): return 'Origin'
        case (x, 0): return f'On x-axis at {x}'
        case (0, y): return f'On y-axis at {y}'
        case (x, y): return f'Point at ({x}, {y})'

print(describe_point((0, 0)))   # Origin
print(describe_point((3, 0)))   # On x-axis at 3
print(describe_point((2, 5)))   # Point at (2, 5)

Nested Conditionals and Short-Circuit Evaluation

Python evaluates boolean expressions lazily: and stops at the first False, or at the first True. This helps you avoid NoneType errors and expensive function calls. But it also means the order of your conditions matters both for logic and performance.

# Safe access with short-circuit
data = None
if data and data.get('key'):
    print(data['key'])  # never runs, because data is falsy

# Performance: put cheap checks first
def expensive_check():
    # imagine hitting a database
    return True

x = 5
if x > 0 and expensive_check():
    print('Both true')
# expensive_check() only runs if x > 0 is True

# Nested conditionals — prefer flattening
# This:
if condition_a:
    if condition_b:
        do_something()
elif condition_c:
    if condition_d:
        do_other()

# Is better written as:
if condition_a and condition_b:
    do_something()
elif condition_c and condition_d:
    do_other()

Why Your Inline If Breaks in Production (and How to Fix It)

Every junior learns the ternary expression early. It looks clean. It saves lines. But shoving complex logic into one line is how you ship bugs at 2 AM. The ternary evaluates the condition, then returns one of two expressions. That's it. No statements, no side effects you can't trace. The second your 'one-liner' needs a function call with side effects or a multi-step calculation, you've already lost. Write the if block. Your future self, debugging a null pointer at 3 AM, will thank you. The rule is simple: if the true/false expression can't fit on a single line without scrolling, it's too complex. Use the full if-elif-else. Production code is read ten times more than it's written. Write for the reader, not the writer.

# io.thecodeforge

def get_timeout(env: str) -> int:
    """Returns timeout in seconds. 
    Never use inline else for production defaults.
    """
    # BAD: unreadable, hard to debug
    timeout = 30 if env == "prod" else 60 if env == "staging" else 120
    
    # GOOD: explicit, traceable
    if env == "prod":
        return 30
    elif env == "staging":
        return 60
    else:
        return 120

print(get_timeout("dev"))

The Silent Killer: How '==' and 'is' Destroy Your Conditions

I spent three hours last week tracing a bug that boiled down to a single 'is' where an '==' should've been. Here's the deal: '==' checks value equality. 'is' checks identity equality — are both variables pointing to the same object in memory? For integers in a certain range, Python caches objects, so 'is' sometimes works. For strings, it's a coin flip depending on interning. Never use 'is' for value comparisons unless you specifically mean 'are these the same object?'. Same trap applies to None checks: use 'is None', not '== None'. The latter works but is slower and confuses readers. Your conditional logic is only as good as your comparison operators. Get them wrong, and your if-elif-else evaluates to garbage.

# io.thecodeforge

user_input = input("Enter secret: ")
SECRET = "opensesame"

# WRONG: 'is' compares memory address
if user_input is SECRET:
    print("Access granted")   # Will never execute for user input

# RIGHT: '==' compares value
if user_input == SECRET:
    print("Access granted")

# ALSO RIGHT: 'is' for singleton comparisons
if user_input is None:
    print("No input provided")