Python Conditionals — Language Specification¶

object.__bool__(self) -> bool
# Called by bool() and conditional expressions.
# If not defined, __len__ is tried.
# If neither defined, the object is always truthy.

object.__len__(self) -> int
# If __bool__ is absent, a non-zero __len__ makes the object truthy.

object.__lt__(self, other) -> bool | NotImplemented
object.__le__(self, other) -> bool | NotImplemented
object.__eq__(self, other) -> bool | NotImplemented
object.__ne__(self, other) -> bool | NotImplemented
object.__gt__(self, other) -> bool | NotImplemented
object.__ge__(self, other) -> bool | NotImplemented

object.__contains__(self, item) -> bool
# Used by 'item in container'.
# If not defined, Python falls back to iterating over the object.

# Class patterns call __match_args__ to determine positional argument mapping:
cls.__match_args__ = ("attr1", "attr2", ...)

# Example:
class Point:
    __match_args__ = ("x", "y")
    def __init__(self, x, y):
        self.x = x
        self.y = y

x = None or "default"   # x = "default"
y = "value" or "default"  # y = "value"
z = 0 and "unreachable"   # z = 0

result = true_val if cond else false_val

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

result = [] or {}     # result = {}  ([] is falsy, returns {})
result = [1] or {}    # result = [1] (truthy, returns first truthy)
result = 0 or False or None or "found"  # result = "found"

# For None, True, False: 'is' is correct
x = None
if x is None: print("none")      # correct

# For other types: use ==
a = "hello"
b = "hello"
print(a is b)    # True in CPython (string interning) — NOT reliable
print(a == b)    # True — reliable

import re
text = "Version: 3.12.0"
if m := re.search(r"\d+\.\d+\.\d+", text):
    print(f"Found version: {m.group()}")   # Found version: 3.12.0

# Walrus in while loop
data = [1, 2, 3, 4, 5]
while chunk := data[:2]:
    print(chunk)
    del data[:2]

def classify(point):
    match point:
        case (x, y) if x == y:
            return "diagonal"
        case (x, y) if x > 0 and y > 0:
            return "first quadrant"
        case _:
            return "other"

count = 0
def check(n):
    global count
    count += 1
    return n

# Each operand evaluated once:
result = check(1) < check(2) < check(3)
print(count)    # 3  — each called exactly once

# ----------------------------------------------------------------
# 1. Basic if / elif / else
# ----------------------------------------------------------------
def grade(score: int) -> str:
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

print(grade(95))   # A
print(grade(73))   # C
print(grade(45))   # F


# ----------------------------------------------------------------
# 2. Truth value testing
# ----------------------------------------------------------------
values = [0, "", [], None, False, 0.0, set(), {}, "hello", [1], True]
for v in values:
    print(f"{repr(v):15} -> {bool(v)}")


# ----------------------------------------------------------------
# 3. Short-circuit evaluation
# ----------------------------------------------------------------
def side_effect(name, val):
    print(f"  evaluating {name}")
    return val

print("and short-circuit:")
result = side_effect("left", False) and side_effect("right", True)
# Only "left" is printed; right is NOT evaluated

print("or short-circuit:")
result = side_effect("left", True) or side_effect("right", False)
# Only "left" is printed


# ----------------------------------------------------------------
# 4. and/or return values (not necessarily bool)
# ----------------------------------------------------------------
x = None
y = x or "default"
print(y)          # "default"

name = "Alice"
greeting = name and f"Hello, {name}!"
print(greeting)   # "Hello, Alice!"

empty = []
result = empty or [1, 2, 3]
print(result)     # [1, 2, 3]


# ----------------------------------------------------------------
# 5. Conditional expression (ternary)
# ----------------------------------------------------------------
n = 7
label = "odd" if n % 2 != 0 else "even"
print(label)   # odd

# Nested ternary (works but prefer if/elif for readability)
category = "low" if n < 5 else ("high" if n > 10 else "medium")
print(category)   # medium


# ----------------------------------------------------------------
# 6. Chained comparisons
# ----------------------------------------------------------------
x = 5
print(1 < x < 10)    # True
print(0 <= x <= 5)   # True
print(x == 5 == 5)   # True

# Each middle operand evaluated once:
import random
# 0 <= random.randint(0,10) <= 10  (randint called once)


# ----------------------------------------------------------------
# 7. Walrus operator in conditions (PEP 572)
# ----------------------------------------------------------------
import re
text = "order_id: 12345"
if (m := re.search(r"\d+", text)) is not None:
    print(f"Found ID: {m.group()}")   # Found ID: 12345


# ----------------------------------------------------------------
# 8. Structural pattern matching (PEP 634, Python 3.10+)
# ----------------------------------------------------------------
class Point:
    __match_args__ = ("x", "y")
    def __init__(self, x, y):
        self.x = x
        self.y = y

def describe_point(point):
    match point:
        case Point(0, 0):
            return "Origin"
        case Point(x, 0):
            return f"On x-axis at {x}"
        case Point(0, y):
            return f"On y-axis at {y}"
        case Point(x, y) if x == y:
            return f"On diagonal at {x}"
        case Point(x, y):
            return f"Point({x}, {y})"
        case _:
            return "Not a point"

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


# ----------------------------------------------------------------
# 9. match with sequence patterns
# ----------------------------------------------------------------
def http_action(request):
    match request:
        case {"method": "GET", "url": url}:
            return f"GET {url}"
        case {"method": "POST", "url": url, "body": body}:
            return f"POST {url} with body"
        case {"method": method}:
            return f"Unknown method: {method}"
        case _:
            return "Invalid request"

print(http_action({"method": "GET", "url": "/home"}))
print(http_action({"method": "DELETE", "url": "/res"}))


# ----------------------------------------------------------------
# 10. match with OR patterns
# ----------------------------------------------------------------
def classify_status(code: int) -> str:
    match code:
        case 200 | 201 | 202:
            return "success"
        case 301 | 302:
            return "redirect"
        case 400 | 401 | 403 | 404:
            return "client error"
        case 500 | 502 | 503:
            return "server error"
        case _:
            return "unknown"

print(classify_status(201))   # success
print(classify_status(404))   # client error
print(classify_status(503))   # server error