Conditionals — Find the Bug¶

def is_in_range(n):
    if n >= 1 and n <= 100:
        return True
    return False

# Even better — Pythonic chained comparison:
def is_in_range(n):
    return 1 <= n <= 100

def even_or_odd(n):
    if n % 2 == 0:
        return "even"
    else:
        return "odd"

def is_admin(role):
    if role == "admin":
        return True
    return False

# Even better:
def is_admin(role):
    return role == "admin"

def get_discount(age, is_member):
    if age >= 65:
        discount = 20
    elif is_member:
        discount = 30
    else:
        discount = 0
    return discount

def connect(host, port=None):
    if port is None:
        port = 8080
    print(f"Connecting to {host}:{port}")

# Option 1: Evaluate both independently
is_valid = validate(user)
logged = log(f"Checking user: {user['name']}")
if is_valid or logged:
    print("User processed")

# Option 2: Use 'and' if you want logging only on valid users
if validate(user):
    log(f"Checking user: {user['name']}")
    print("User processed")

print(check(101))  # Returns True (correct, 101 > 0 and 101 > 100)

def check(n):
    if n > 0 and (n % 2 == 0 or n > 100):
        return True
    return False

def lists_equal(a, b):
    return a == b  # Use == for value comparison

# Solution 1: Use a class with dotted names
class Status:
    OK = 200
    NOT_FOUND = 404
    ERROR = 500

def status_message(code):
    match code:
        case Status.OK:
            return "Success"
        case Status.NOT_FOUND:
            return "Not Found"
        case Status.ERROR:
            return "Server Error"
        case _:
            return "Unknown"

# Solution 2: Use literal values directly
def status_message(code):
    match code:
        case 200:
            return "Success"
        case 404:
            return "Not Found"
        case 500:
            return "Server Error"
        case _:
            return "Unknown"

# Solution 3: Use guards
def status_message(code):
    match code:
        case c if c == OK:
            return "Success"
        case c if c == NOT_FOUND:
            return "Not Found"
        case c if c == ERROR:
            return "Server Error"
        case _:
            return "Unknown"

# Solution 1: Don't rely on leaked variable
def process_data(items):
    filtered = [y for x in items if (y := x * 2) > 10]
    # Don't use 'y' outside the comprehension
    return filtered

# Solution 2: Use explicit loop for clarity
def process_data(items):
    filtered = []
    for x in items:
        doubled = x * 2
        if doubled > 10:
            filtered.append(doubled)
    return filtered

# You expect a strict count but get wrong results with mixed types
count_true(1, 0, 1)  # Returns 2 — same as with bools!
count_true(5, 3, 2)  # Returns 10 — not the "count of truthy values"!

def count_true(*args) -> int:
    return sum(bool(a) for a in args)

# Now:
print(count_true(5, 0, 2))  # 2 (two truthy values)
print(count_true(True, False, True))  # 2

def categorize(item, high=None, low=None):
    if high is None:
        high = []
    if low is None:
        low = []
    if item > 50:
        high.append(item)
    else:
        low.append(item)
    return high, low

def is_outside_range_v2(x):
    if not (1 <= x <= 10):
        return True
    return False

def sort_with_nones(items):
    """Sort items with None values pushed to the end."""
    return sorted(items, key=lambda x: (x is None, x if x is not None else 0))

# How it works:
# - (False, value) for non-None items → sorted by value
# - (True, 0) for None items → sorted after all non-None (True > False)

print(sort_with_nones([3, 1, None, 2]))    # [1, 2, 3, None]
print(sort_with_nones(["b", None, "a"]))   # ['a', 'b', None]