Variables and Data Types — Find the Bug¶

def add_student(name, students=None):
    """Add a student to the list and return the list."""
    if students is None:
        students = []
    students.append(name)
    return students

result1 = add_student("Alice")
result2 = add_student("Bob")
result3 = add_student("Charlie")

print(result1)  # ["Alice"]
print(result2)  # ["Bob"]
print(result3)  # ["Charlie"]

def check_none(value):
    """Check if a value is None, False, or zero — using identity for singletons."""
    if value is None:
        return "Value is None"
    elif value is False:
        return "Value is False"
    elif value == 0:
        return "Value is zero"
    else:
        return f"Value is {value}"

print(check_none(None))     # "Value is None"
print(check_none(False))    # "Value is False"
print(check_none(0))        # "Value is zero"
print(check_none(""))       # "Value is "

def create_matrix(rows, cols, default=0):
    """Create a matrix (list of lists) filled with default value."""
    return [[default] * cols for _ in range(rows)]


grid = create_matrix(3, 3, 0)
grid[0][0] = 99
print(grid)  # [[99, 0, 0], [0, 0, 0], [0, 0, 0]]

import math
from decimal import Decimal


def calculate_total(prices):
    """Calculate total price with tax — using proper float comparison."""
    subtotal = sum(prices)
    tax = subtotal * 0.1
    total = subtotal + tax

    expected = 33.0
    if math.isclose(total, expected, rel_tol=1e-9):
        print(f"Total: ${total:.2f} - CORRECT")
    else:
        print(f"Total: ${total:.2f} - ERROR! Expected ${expected:.2f}")
    return total


# For financial calculations, use Decimal:
def calculate_total_precise(prices: list[str]) -> Decimal:
    """Calculate total using Decimal for exact arithmetic."""
    decimal_prices = [Decimal(p) for p in prices]
    subtotal = sum(decimal_prices)
    tax = subtotal * Decimal("0.1")
    return subtotal + tax


print(calculate_total_precise(["0.1", "0.2", "0.3"]))  # 0.66 exactly

# Option 1: Use global keyword
x = 10

def modify():
    global x
    print(f"x before: {x}")
    x = x + 1
    print(f"x after: {x}")

modify()

# Option 2 (better): Pass as argument and return
def modify_pure(value: int) -> int:
    print(f"x before: {value}")
    value = value + 1
    print(f"x after: {value}")
    return value

x = 10
x = modify_pure(x)

# Fix 1: Capture i as a default argument
def create_multipliers():
    multipliers = []
    for i in range(5):
        multipliers.append(lambda x, i=i: x * i)  # i=i captures current value
    return multipliers

# Fix 2: Use functools.partial
from functools import partial

def create_multipliers_v2():
    def multiply(i, x):
        return x * i
    return [partial(multiply, i) for i in range(5)]

# Fix 3: Use a factory function
def create_multipliers_v3():
    def make_mult(i):
        return lambda x: x * i
    return [make_mult(i) for i in range(5)]

mults = create_multipliers()
for idx in range(5):
    print(f"mults[{idx}](10) = {mults[idx](10)}")  # 0, 10, 20, 30, 40

def cache_lookup(key, cache):
    """Look up a key in cache using value comparison."""
    for cached_key, value in cache.items():
        if key == cached_key:  # Use == for value comparison
            return value
    return None

# Or simply use dict's built-in lookup (which uses == internally):
def cache_lookup_simple(key, cache):
    return cache.get(key)

def parse_config(config_str: str) -> dict:
    """Parse a simple key=value config string with proper type detection."""
    config = {}
    for line in config_str.strip().split("\n"):
        if not line.strip() or "=" not in line:
            continue
        key, value = line.split("=", 1)
        key = key.strip()
        value = value.strip()

        if value.lower() == "true":
            config[key] = True
        elif value.lower() == "false":
            config[key] = False
        else:
            # Try int first, then float, then keep as string
            try:
                config[key] = int(value)
            except ValueError:
                try:
                    config[key] = float(value)
                except ValueError:
                    config[key] = value

    return config

config = parse_config(config_text)
print(config)
# {'port': 8080, 'debug': True, 'name': 'MyApp', 'timeout': -30, 'ratio': 3.14, 'count': 0}

import copy


def process_users(users_data: list[dict]) -> list[dict]:
    """Process user data: add computed fields without modifying the original."""
    # Option 1: Deep copy
    processed = copy.deepcopy(users_data)

    # Option 2: Create new dicts
    # processed = [{**user} for user in users_data]

    for user in processed:
        user["full_name"] = f"{user['first_name']} {user['last_name']}"
        user["email_lower"] = user["email"].lower()

    return processed

original = [
    {"first_name": "Alice", "last_name": "Smith", "email": "Alice@Example.com"},
]
processed = process_users(original)
print("original keys:", list(original[0].keys()))   # Only original keys
print("processed keys:", list(processed[0].keys()))  # Includes computed fields

def count_active_users(users: list[dict]) -> dict:
    """Count active and inactive users with proper type handling."""
    active = 0
    inactive = 0

    for user in users:
        # Convert to bool explicitly — handles any truthy/falsy value
        is_active = bool(user["is_active"])
        if is_active:
            active += 1
        else:
            inactive += 1

    return {"active": active, "inactive": inactive, "total": active + inactive}


users = [
    {"name": "Alice", "is_active": True},
    {"name": "Bob", "is_active": False},
    {"name": "Charlie", "is_active": 1},
    {"name": "Dave", "is_active": 0},
    {"name": "Eve", "is_active": "yes"},
    {"name": "Frank", "is_active": ""},
]

result = count_active_users(users)
print(result)  # {'active': 3, 'inactive': 3, 'total': 6}

import threading

counter = 0
lock = threading.Lock()


def increment(n: int) -> None:
    """Increment global counter n times — thread-safe."""
    global counter
    for _ in range(n):
        with lock:
            counter += 1


# Or better: avoid global state entirely
from collections import defaultdict

def increment_local(n: int) -> int:
    """Return local count — no shared state."""
    return n


threads = []
results = []

def worker(n: int) -> None:
    results.append(increment_local(n))

lock2 = threading.Lock()

def worker_safe(n: int) -> None:
    count = increment_local(n)
    with lock2:
        results.append(count)

threads = [threading.Thread(target=worker_safe, args=(100_000,)) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(f"Total: {sum(results):,}")  # Always 1,000,000

def build_lookup(items: list) -> dict:
    """Build a lookup table with type-aware keys."""
    lookup = {}
    for item in items:
        key = item["key"]
        # Use (type_name, value) as composite key to distinguish types
        typed_key = (type(key).__name__, key)
        lookup[typed_key] = item["value"]
    return lookup


items = [
    {"key": True, "value": "boolean_true"},
    {"key": 1, "value": "integer_one"},
    {"key": 1.0, "value": "float_one"},
    {"key": False, "value": "boolean_false"},
    {"key": 0, "value": "integer_zero"},
    {"key": 0.0, "value": "float_zero"},
]

lookup = build_lookup(items)
print(f"Number of entries: {len(lookup)}")  # 6
for k, v in lookup.items():
    print(f"  {k} -> {v}")