Python Functions & Builtin Functions — Find the Bug¶

def add_to_cart(item, cart=None):
    """Add an item to the shopping cart"""
    if cart is None:
        cart = []
    cart.append(item)
    return cart

# Customer 1
cart1 = add_to_cart("apple")
cart1 = add_to_cart("banana", cart1)
print(f"Customer 1: {cart1}")  # ['apple', 'banana']

# Customer 2
cart2 = add_to_cart("milk")
print(f"Customer 2: {cart2}")  # ['milk']  Correct!

def calculate_total(prices, tax_rate=0.08):
    """Calculate total price with tax"""
    subtotal = sum(prices)
    tax = subtotal * tax_rate
    total = subtotal + tax
    print(f"Subtotal: ${subtotal:.2f}, Tax: ${tax:.2f}, Total: ${total:.2f}")
    return total  # <-- FIX: return the result

prices = [10.99, 24.99, 5.50]
result = calculate_total(prices)
discounted = result * 0.9
print(f"After 10% discount: ${discounted:.2f}")

counter = 0

def increment():
    global counter  # <-- FIX: declare as global
    counter += 1

def get_counter():
    return counter

increment()
increment()
increment()
print(f"Counter: {get_counter()}")  # Counter: 3

# Better approach: avoid global state
class Counter:
    def __init__(self):
        self.value = 0

    def increment(self):
        self.value += 1

    def get(self):
        return self.value

c = Counter()
c.increment()
c.increment()
c.increment()
print(f"Counter: {c.get()}")  # Counter: 3

# Fix 1: Default argument captures current value
def create_buttons_v1():
    buttons = []
    for i in range(5):
        def on_click(i=i):  # <-- FIX: default arg captures current i
            print(f"Button {i} clicked")
        buttons.append(on_click)
    return buttons

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

def create_buttons_v2():
    def on_click(i):
        print(f"Button {i} clicked")
    return [partial(on_click, i) for i in range(5)]

# Fix 3: Factory function creates a new scope
def create_buttons_v3():
    def make_handler(i):
        def on_click():
            print(f"Button {i} clicked")
        return on_click
    return [make_handler(i) for i in range(5)]

print("=== Fix 1 (default arg) ===")
for btn in create_buttons_v1():
    btn()

print("\n=== Fix 2 (partial) ===")
for btn in create_buttons_v2():
    btn()

print("\n=== Fix 3 (factory) ===")
for btn in create_buttons_v3():
    btn()

def merge_configs(*configs, **overrides):
    """Merge multiple config dicts and apply overrides"""
    result = {}
    for config in configs:
        result.update(config)
    result.update(overrides)
    return result

defaults = {"host": "localhost", "port": 8080, "debug": True}
extra = {"port": 443}

# Fix 1: Merge the dicts before unpacking
merged_kwargs = {**defaults, **extra}  # Dict merge handles duplicates
result = merge_configs(**merged_kwargs)
print(f"Fix 1: {result}")

# Fix 2: Pass as positional dict arguments
result = merge_configs(defaults, extra)
print(f"Fix 2: {result}")

# Fix 3: Use | operator (Python 3.9+)
result = merge_configs(defaults | extra)
print(f"Fix 3: {result}")

import time
import functools

def timer(func):
    @functools.wraps(func)  # <-- FIX: preserves metadata
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f}s")
        return result
    return wrapper

@timer
def fetch_data(url):
    """Fetch data from a URL"""
    time.sleep(0.1)
    return {"data": "result"}

# Now metadata is preserved
print(f"Function name: {fetch_data.__name__}")  # 'fetch_data'
print(f"Docstring: {fetch_data.__doc__}")        # 'Fetch data from a URL'

# Can access original via __wrapped__
print(f"Original: {fetch_data.__wrapped__}")

# Signature is correct
import inspect
print(f"Signature: {inspect.signature(fetch_data)}")  # (url)

def process_data(items):
    """Process a list of items"""
    # Use descriptive names that don't shadow builtins
    valid_items = [item for item in items if item > 0]
    unique_items = set(valid_items)  # Now set() works as a constructor
    sorted_items = sorted(unique_items)

    total = sum(sorted_items)
    count = len(sorted_items)

    return {
        "items": valid_items,
        "unique": unique_items,
        "sorted": sorted_items,
        "total": total,
        "count": count,
    }

result = process_data([3, -1, 4, 1, 5, 9, 2, 6, 5, 3])
print(result)

# Common builtin names to NEVER use as variables:
# list, dict, set, tuple, str, int, float, bool, type,
# id, input, print, len, range, map, filter, zip, sum,
# min, max, sorted, reversed, enumerate, any, all, hash,
# format, open, file, dir, help, next, iter, super, object

def make_accumulator(initial_values):
    """Create an accumulator that tracks values"""
    values = list(initial_values)  # <-- FIX 1: copy the list

    def add(x):
        nonlocal values
        values.append(x)
        return sum(values)

    def reset():
        nonlocal values
        values = list(initial_values)  # <-- FIX 2: reset to a copy of initial

    def get():
        return list(values)  # <-- FIX 3: return a copy to prevent external mutation

    return add, reset, get

original = [1, 2, 3]
add, reset, get = make_accumulator(original)

add(4)
print(f"Accumulator: {get()}")  # [1, 2, 3, 4]
print(f"Original: {original}")  # [1, 2, 3]  <-- safe!

reset()
add(10)
print(f"After reset+add: {get()}")  # [1, 2, 3, 10]
print(f"Original: {original}")      # [1, 2, 3]  <-- still safe!

def create_processors(operations):
    """Create a list of data processors from operation configs"""
    processors = []

    for op in operations:
        name = op["name"]
        params = dict(op.get("params", {}))  # <-- FIX: copy the dict

        def process(data, name=name, params=params):
            for item in data:
                if name == "double":
                    yield item * params.get("factor", 2)
                elif name == "filter":
                    if item > params.get("threshold", 0):
                        yield item
                elif name == "offset":
                    yield item + params.get("amount", 0)

        processors.append(process)

    return processors

# Alternative fix using a factory function for complete isolation:
def create_processors_v2(operations):
    def make_processor(name, params):
        params = dict(params)  # Defensive copy
        def process(data):
            for item in data:
                if name == "double":
                    yield item * params.get("factor", 2)
                elif name == "filter":
                    if item > params.get("threshold", 0):
                        yield item
                elif name == "offset":
                    yield item + params.get("amount", 0)
        return process

    return [make_processor(op["name"], op.get("params", {})) for op in operations]

# Test
operations = [
    {"name": "double", "params": {"factor": 3}},
    {"name": "filter", "params": {"threshold": 5}},
    {"name": "offset", "params": {"amount": 10}},
]

processors = create_processors(operations)
operations[0]["params"]["factor"] = 100  # This no longer affects processors

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for proc in processors:
    result = list(proc(data))
    print(f"Result: {result}")
# double now correctly uses factor=3

def make_tree_printer(indent_char="  "):
    """Create a function that pretty-prints a tree structure"""

    def print_tree(node, depth=0):
        prefix = indent_char * depth
        print(f"{prefix}{node['name']}")

        children = node.get("children", [])

        # FIX: Use sorted() which returns a NEW list instead of sort() which mutates
        for child in sorted(children, key=lambda c: c["name"]):
            print_tree(child, depth + 1)

    return print_tree

tree = {
    "name": "root",
    "children": [
        {
            "name": "charlie",
            "children": [
                {"name": "zeta"},
                {"name": "alpha"},
            ]
        },
        {"name": "alice"},
        {"name": "bob"},
    ]
}

printer = make_tree_printer()
print("=== Print (sorted display) ===")
printer(tree)

print(f"\nOriginal order preserved: {[c['name'] for c in tree['children']]}")
# ['charlie', 'alice', 'bob'] — unchanged!

import time
import functools
from collections import deque

class RateLimitExceeded(Exception):
    """Raised when rate limit is exceeded"""
    pass

def create_rate_limiter(max_calls=5, period=60, log=None):
    """Create a rate limiter that limits function calls"""
    if log is None:  # FIX Bug 2: don't use mutable default
        log = []

    call_times = deque()  # deque is more efficient for popleft

    def limiter(func):
        @functools.wraps(func)  # Bonus fix: preserve metadata
        def wrapper(*args, **kwargs):
            now = time.time()

            # Clean up old entries
            while call_times and call_times[0] < now - period:
                call_times.popleft()  # FIX Bug 1: remove from the LEFT (oldest)

            if len(call_times) >= max_calls:
                log.append(f"Rate limited: {func.__name__}")
                raise RateLimitExceeded(  # FIX Bug 3: raise exception instead of silent None
                    f"{func.__name__} rate limit exceeded: "
                    f"{max_calls} calls per {period}s"
                )

            call_times.append(now)
            log.append(f"Called: {func.__name__}")
            result = func(*args, **kwargs)
            return result  # FIX Bug 4: actually return the result!

        return wrapper
    return limiter

# Usage
@create_rate_limiter(max_calls=2, period=1)
def api_call(endpoint):
    """Call an API endpoint"""
    return f"Response from {endpoint}"

for i in range(5):
    try:
        result = api_call(f"/api/{i}")
        print(f"Call {i}: {result}")
    except RateLimitExceeded as e:
        print(f"Call {i}: BLOCKED - {e}")

# Now we get:
# Call 0: Response from /api/0
# Call 1: Response from /api/1
# Call 2: BLOCKED - api_call rate limit exceeded: 2 calls per 1s
# Call 3: BLOCKED - ...
# Call 4: BLOCKED - ...