← Decorators & Closures

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

What is a closure in Python, and how does it capture variables from its enclosing scope?

A closure is a function object that remembers values in its enclosing lexical scope even when the scope has finished executing. In Python, when an inner function references a variable from an outer (enclosing) function, and the outer function returns the inner function, a closure is formed. The inner function 'closes over' the free variables from the enclosing scope.

Python implements closures through the __closure__ attribute, which holds cell objects that contain references to the captured variables. Importantly, closures capture references to variables, not their values at the time the closure is created. This means if the variable changes before the closure is called, the closure sees the updated value.

The __code__.co_freevars attribute lists the names of the free variables captured by the closure.

Pseudo Code

1. Define an outer function with a local variable
2. Define an inner function that references the outer variable
3. Return the inner function from the outer function
4. The returned function retains access to the outer variable
5. The outer function's local scope is preserved in __closure__

Code

def make_multiplier(factor):
    """Outer function creates a closure over 'factor'."""
    def multiplier(x):
        return x * factor
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))   # 10
print(triple(5))   # 15

# Inspecting the closure
print(double.__closure__)              # (<cell at 0x...>,)
print(double.__closure__[0].cell_contents)  # 2
print(double.__code__.co_freevars)     # ('factor',)

# Late binding demonstration
def make_functions():
    funcs = []
    for i in range(3):
        def f():
            return i  # captures reference to i, not its value
        funcs.append(f)
    return funcs

results = [f() for f in make_functions()]
print(results)  # [2, 2, 2] -- all see the final value of i

# Fix with default argument to capture current value
def make_functions_fixed():
    funcs = []
    for i in range(3):
        def f(i=i):  # default arg captures current value
            return i
        funcs.append(f)
    return funcs

results = [f() for f in make_functions_fixed()]
print(results)  # [0, 1, 2]

10
15
(<cell at <address>: int object at <address>>,)
2
('factor',)
[2, 2, 2]
[0, 1, 2]

Key Points

•A closure captures references to variables, not copies of their values
•The __closure__ attribute holds cell objects with captured variable references
•Closures allow data encapsulation without classes
•co_freevars lists the names of captured free variables

Gotchas

•Late binding: closures in loops all share the same variable reference, so they all see the last value
•Use default arguments (def f(i=i)) or functools.partial to capture current loop values
•If the enclosing scope variable is reassigned, the closure sees the new value

A closure is an inner function that remembers variables from its enclosing function's scope, even after the outer function has returned. It captures references to those variables, not their values.

•Inner function + reference to enclosing variable + returned from outer = closure
•Captures references, not values (late binding)

def make_greeter(greeting):
    def greet(name):
        return f"{greeting}, {name}!"
    return greet

hello = make_greeter("Hello")
print(hello("Alice"))  # Hello, Alice!
print(hello.__closure__[0].cell_contents)  # "Hello"

Hello, Alice!
Hello

Closures in loops all share the same loop variable -- use default args to fix

Question 2 / 15

How does the `nonlocal` keyword work, and when would you use it?

The nonlocal keyword in Python allows an inner function to modify a variable in its enclosing (non-global) scope. Without nonlocal, assigning to a variable inside an inner function creates a new local variable that shadows the outer one. The nonlocal statement tells Python that the variable should refer to the one in the nearest enclosing scope that is not the global scope.

This is different from the global keyword, which refers to module-level variables. nonlocal specifically targets enclosing function scopes (the 'E' in the LEGB rule).

Common use cases include:

Creating stateful closures (counters, accumulators)
Implementing memoization without mutable default arguments
Building decorators that maintain internal state

Pseudo Code

1. Define outer function with a local variable
2. Define inner function that needs to modify that variable
3. Declare the variable as nonlocal inside the inner function
4. Now assignments in the inner function modify the outer variable
5. Without nonlocal, assignment would create a new local variable

Code

# Without nonlocal -- this creates a local variable
def counter_broken():
    count = 0
    def increment():
        count = count + 1  # UnboundLocalError!
        return count
    return increment

# With nonlocal -- modifies the enclosing variable
def counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

c = counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

# Practical example: running average
def make_averager():
    total = 0.0
    count = 0
    def averager(new_value):
        nonlocal total, count
        total += new_value
        count += 1
        return total / count
    return averager

avg = make_averager()
print(avg(10))  # 10.0
print(avg(20))  # 15.0
print(avg(30))  # 20.0

# nonlocal vs global
x = 100  # global
def outer():
    x = 10  # enclosing
    def inner():
        nonlocal x  # refers to outer's x (10), not global x (100)
        x += 1
        return x
    return inner()

print(outer())  # 11
print(x)        # 100 -- global unchanged

Key Points

•nonlocal allows modification of enclosing scope variables (not global)
•Without nonlocal, assignment creates a new local variable causing UnboundLocalError
•nonlocal targets the nearest enclosing function scope
•You can declare multiple variables: nonlocal a, b, c

Gotchas

•nonlocal only works with enclosing function scopes, not the global scope -- use global for that
•The variable must already exist in an enclosing scope; nonlocal cannot create new variables
•SyntaxError if used at module level or if variable is not found in any enclosing scope

nonlocal lets an inner function modify a variable from its enclosing function scope. Without it, assigning to that variable creates a new local one instead.

•nonlocal modifies enclosing function variables, global modifies module-level
•Without nonlocal, assignment creates a new local variable

def counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

c = counter()
print(c(), c(), c())  # 1 2 3

1 2 3

The variable must already exist in an enclosing scope -- nonlocal cannot create variables

Question 3 / 15

How do you write a basic function decorator in Python?

A decorator is a function that takes another function as an argument, adds some behavior, and returns a new function (the wrapper). The @decorator syntax is syntactic sugar for func = decorator(func).

A well-written decorator follows this pattern:

Define a decorator function that accepts a function
Inside it, define a wrapper function that calls the original
The wrapper should accept *args, **kwargs to work with any function signature
Use @functools.wraps(func) to preserve the original function's metadata
Return the wrapper function

Decorators are widely used for cross-cutting concerns: logging, timing, authentication, caching, input validation, and retry logic.

Pseudo Code

1. Import functools
2. Define decorator(func):
3.   Define wrapper(*args, **kwargs):
4.     - Do something before calling func
5.     - result = func(*args, **kwargs)
6.     - Do something after calling func
7.     - Return result
8.   Decorate wrapper with @functools.wraps(func)
9.   Return wrapper
10. Apply with @decorator above function definition

Code

import functools
import time

def timer(func):
    """Decorator that measures execution time."""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function(n):
    """Simulate a slow computation."""
    total = sum(range(n))
    return total

result = slow_function(1_000_000)
print(result)  # 499999500000
# Output: slow_function took 0.0312s

# Without @ syntax, equivalent to:
# slow_function = timer(slow_function)

# Metadata is preserved thanks to @functools.wraps
print(slow_function.__name__)  # 'slow_function' (not 'wrapper')
print(slow_function.__doc__)   # 'Simulate a slow computation.'

# Another example: logging decorator
def log_calls(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_repr = [repr(a) for a in args]
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
        signature = ", ".join(args_repr + kwargs_repr)
        print(f"Calling {func.__name__}({signature})")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result!r}")
        return result
    return wrapper

@log_calls
def add(a, b):
    return a + b

add(3, 4)
# Calling add(3, 4)
# add returned 7

slow_function took 0.0068s
499999500000
slow_function
Simulate a slow computation.
Calling add(3, 4)
add returned 7

Key Points

•A decorator takes a function, wraps it, and returns the wrapper
•@decorator syntax is sugar for func = decorator(func)
•Use *args, **kwargs to handle any function signature
•Always use @functools.wraps to preserve the original function's metadata

Gotchas

•Forgetting @functools.wraps causes __name__, __doc__, and other metadata to be lost
•Forgetting to return the result of func(*args, **kwargs) will make the decorated function return None
•The decorator is called once at definition time, the wrapper is called each time the function is invoked

A decorator wraps a function to add behavior. Use @functools.wraps to preserve metadata, accept *args, **kwargs for flexibility, and always return the original function's result.

•@decorator is sugar for func = decorator(func)
•Always use @functools.wraps and return the result

import functools

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        import time
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__}: {time.perf_counter() - start:.4f}s")
        return result
    return wrapper

@timer
def compute(n):
    return sum(range(n))

compute(1_000_000)

compute: 0.0069s

Without @functools.wraps, the original function's __name__ and __doc__ are lost

Question 4 / 15

How do you create a decorator that accepts arguments (parameterized decorator)?

A parameterized decorator (also called a decorator factory) requires an extra level of nesting. When you write @decorator(arg), Python first calls decorator(arg) which must return the actual decorator function. This three-level pattern is:

Outer function: takes the decorator's parameters
Middle function: takes the function being decorated (this is the actual decorator)
Inner function: the wrapper that replaces the original function

The key insight is that @decorator(arg) is evaluated in two steps:

First: decorator(arg) is called, returning a decorator
Second: that returned decorator is applied to the function

This pattern is essential for configurable decorators like @retry(max_attempts=3) or @route('/path').

Pseudo Code

1. Define decorator_factory(param1, param2):
2.   Define decorator(func):
3.     Define wrapper(*args, **kwargs):
4.       - Use param1, param2 to control behavior
5.       - Call and return func(*args, **kwargs)
6.     Apply @functools.wraps(func) to wrapper
7.     Return wrapper
8.   Return decorator
9. Use as @decorator_factory(param1, param2)

Code

import functools
import time

def retry(max_attempts=3, delay=1.0):
    """Decorator factory that retries a function on exception."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    print(f"Attempt {attempt}/{max_attempts} failed: {e}")
                    if attempt < max_attempts:
                        time.sleep(delay)
            raise last_exception
        return wrapper
    return decorator

@retry(max_attempts=3, delay=0.1)
def flaky_api_call():
    import random
    if random.random() < 0.7:
        raise ConnectionError("Network timeout")
    return {"status": "ok"}

# Another example: repeat decorator
def repeat(n):
    """Run the decorated function n times."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            result = None
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")
# Hello, Alice!
# Hello, Alice!
# Hello, Alice!

# Under the hood, @repeat(3) does:
# greet = repeat(3)(greet)
# Step 1: repeat(3) returns decorator
# Step 2: decorator(greet) returns wrapper

Hello, Alice!
Hello, Alice!
Hello, Alice!

Key Points

•Three levels of nesting: factory -> decorator -> wrapper
•@decorator(args) first calls the factory, then applies the returned decorator
•The factory function captures the configuration parameters via closure
•Equivalent to: func = decorator_factory(args)(func)

Gotchas

•Forgetting parentheses: @retry vs @retry() -- without () the function itself is passed as max_attempts
•To make parentheses optional, you need special handling to detect if the first arg is a function
•Each level of nesting serves a distinct purpose; mixing them up causes confusing errors

A parameterized decorator uses three levels of nesting: the outer function takes parameters, returns a decorator, which returns a wrapper. @deco(arg) calls deco(arg) first, then applies the result to the function.

•Three levels: factory(params) -> decorator(func) -> wrapper(*args, **kwargs)
•@repeat(3) means func = repeat(3)(func)

import functools

def repeat(n):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hi():
    print("Hi!")

say_hi()  # prints "Hi!" three times

Hi!
Hi!
Hi!

@repeat vs @repeat() -- forgetting parentheses passes the function as the parameter

Question 5 / 15

What does `functools.wraps` do and why is it important?

functools.wraps is a decorator that copies metadata from the original function to the wrapper function. When you create a decorator, the wrapper function replaces the original, and without @functools.wraps, the wrapper's own metadata (name, docstring, module, etc.) overwrites the original's.

Specifically, functools.wraps copies these attributes:

__name__ -- the function name
__qualname__ -- the qualified name
__doc__ -- the docstring
__module__ -- the module where the function was defined
__annotations__ -- type annotations
__dict__ -- the function's attribute dictionary
__wrapped__ -- a reference to the original function (added, not copied)

The __wrapped__ attribute is especially useful because it lets you access the original unwrapped function, which is helpful for testing and debugging.

functools.wraps is itself a decorator that calls functools.update_wrapper under the hood.

Pseudo Code

1. Without @wraps: wrapper.__name__ == 'wrapper', wrapper.__doc__ == None
2. With @wraps(func): wrapper.__name__ == func.__name__, etc.
3. wraps copies __name__, __qualname__, __doc__, __module__, __annotations__
4. wraps also sets __wrapped__ to point to the original function
5. Enables help(), debugging, and introspection to work correctly

Code

import functools

# WITHOUT functools.wraps
def bad_decorator(func):
    def wrapper(*args, **kwargs):
        """I am the wrapper."""
        return func(*args, **kwargs)
    return wrapper

@bad_decorator
def greet(name):
    """Greet someone by name."""
    return f"Hello, {name}!"

print(greet.__name__)   # 'wrapper' -- WRONG!
print(greet.__doc__)    # 'I am the wrapper.' -- WRONG!

# WITH functools.wraps
def good_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        """I am the wrapper."""
        return func(*args, **kwargs)
    return wrapper

@good_decorator
def greet(name):
    """Greet someone by name."""
    return f"Hello, {name}!"

print(greet.__name__)     # 'greet' -- correct
print(greet.__doc__)      # 'Greet someone by name.' -- correct
print(greet.__wrapped__)  # <function greet at 0x...> -- original function

# Accessing the original unwrapped function
original = greet.__wrapped__
print(original("Alice"))  # "Hello, Alice!" -- bypasses decorator

# This matters for tools like help(), inspect, and documentation generators
import inspect
print(inspect.signature(greet))  # (name) -- correct signature

wrapper
I am the wrapper.
greet
Greet someone by name.
<function greet at <address>>
Hello, Alice!
(name)

Key Points

•Copies __name__, __qualname__, __doc__, __module__, __annotations__ from original to wrapper
•Sets __wrapped__ attribute pointing to the original function
•Essential for debugging, help(), and documentation tools
•Uses functools.update_wrapper internally

Gotchas

•Without @wraps, tools like Sphinx, help(), and pytest may show incorrect function info
•Some frameworks (Flask, Django) rely on __name__ for routing -- missing @wraps can break them
•__wrapped__ allows bypassing the decorator, which can be a security concern in auth decorators

functools.wraps copies the original function's metadata (__name__, __doc__, etc.) to the wrapper function. Without it, the decorated function loses its identity.

•Preserves __name__, __doc__, __module__, __annotations__
•Also adds __wrapped__ pointing to the original function

import functools

def my_decorator(func):
    @functools.wraps(func)  # preserves func's metadata
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def hello():
    """Say hello."""
    pass

print(hello.__name__)  # 'hello' (not 'wrapper')
print(hello.__doc__)   # 'Say hello.'

hello
Say hello.

Flask route decorators depend on __name__ -- missing @wraps can cause routing errors

Question 6 / 15

How do you stack (chain) multiple decorators on a single function?

You can apply multiple decorators to a single function by stacking @decorator lines. The decorators are applied from bottom to top (innermost to outermost), but when the function is called, they execute from top to bottom (outermost to innermost).

Given:

@decorator_a
@decorator_b
def func(): ...

This is equivalent to: func = decorator_a(decorator_b(func))

So decorator_b wraps func first, then decorator_a wraps the result. When func() is called, decorator_a's wrapper runs first, which calls decorator_b's wrapper, which calls the original func.

Order matters when decorators depend on each other. For example, an authentication decorator should run before a logging decorator if you want to log only authenticated requests.

Pseudo Code

1. @A, @B, @C on func means: func = A(B(C(func)))
2. Application order: C first, then B, then A (bottom to top)
3. Execution order: A's wrapper -> B's wrapper -> C's wrapper -> func
4. Return order: func -> C's wrapper -> B's wrapper -> A's wrapper

Code

import functools

def bold(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return f"<b>{func(*args, **kwargs)}</b>"
    return wrapper

def italic(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return f"<i>{func(*args, **kwargs)}</i>"
    return wrapper

def underline(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return f"<u>{func(*args, **kwargs)}</u>"
    return wrapper

@bold
@italic
@underline
def greet(name):
    return f"Hello, {name}"

# Equivalent to: greet = bold(italic(underline(greet)))
print(greet("Alice"))  # <b><i><u>Hello, Alice</u></i></b>

# Demonstrating execution order with logging
def decorator(name):
    def actual_decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print(f"Entering {name}")
            result = func(*args, **kwargs)
            print(f"Exiting {name}")
            return result
        return wrapper
    return actual_decorator

@decorator("A")
@decorator("B")
@decorator("C")
def my_func():
    print("Running my_func")
    return "done"

my_func()
# Entering A
# Entering B
# Entering C
# Running my_func
# Exiting C
# Exiting B
# Exiting A

<b><i><u>Hello, Alice</u></i></b>
Entering A
Entering B
Entering C
Running my_func
Exiting C
Exiting B
Exiting A

Key Points

•Decorators are applied bottom-to-top but execute top-to-bottom
•@A @B @C def f means f = A(B(C(f)))
•The outermost decorator's wrapper runs first on each call
•Order matters when decorators have dependencies

Gotchas

•Confusing application order (bottom-up) with execution order (top-down)
•A decorator that does not call the wrapped function will break the chain
•If one decorator changes the return type, subsequent decorators may fail

Stack decorators with multiple @ lines. They apply bottom-to-top but execute top-to-bottom. @A @B def f equals f = A(B(f)).

•@A @B def f means f = A(B(f))
•Applied bottom-up, executed top-down

import functools

def bold(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return f"<b>{func(*args, **kwargs)}</b>"
    return wrapper

def italic(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return f"<i>{func(*args, **kwargs)}</i>"
    return wrapper

@bold
@italic
def greet(name):
    return f"Hello, {name}"

print(greet("Alice"))  # <b><i>Hello, Alice</i></b>

<b><i>Hello, Alice</i></b>

Order matters: @auth @log is different from @log @auth

Question 7 / 15

How does the `@property` decorator work in Python?

The @property decorator turns a method into a read-only attribute, providing a clean interface for getter/setter/deleter operations. It uses Python's descriptor protocol under the hood.

The property built-in is actually a class that implements the descriptor protocol (__get__, __set__, __delete__). When you use @property, it creates a property object with the decorated method as the getter. You can then add a setter with @name.setter and a deleter with @name.deleter.

Benefits:

Provides attribute-style access while keeping control over getting/setting
Allows adding validation without changing the public API
Follows the uniform access principle (attribute access looks the same whether computed or stored)

Pseudo Code

1. Define the getter method with @property
2. Optionally define setter with @name.setter
3. Optionally define deleter with @name.deleter
4. Access like a regular attribute: obj.name (calls getter)
5. Assign like a regular attribute: obj.name = value (calls setter)
6. Delete like: del obj.name (calls deleter)

Code

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius  # internal storage

    @property
    def celsius(self):
        """Get temperature in Celsius."""
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature below absolute zero!")
        self._celsius = value

    @celsius.deleter
    def celsius(self):
        print("Resetting temperature")
        self._celsius = 0

    @property
    def fahrenheit(self):
        """Computed property -- read-only."""
        return self._celsius * 9 / 5 + 32

t = Temperature(100)
print(t.celsius)     # 100 (calls getter)
print(t.fahrenheit)  # 212.0 (computed property)

t.celsius = 25       # calls setter with validation
print(t.celsius)     # 25

try:
    t.celsius = -300  # raises ValueError
except ValueError as e:
    print(e)  # Temperature below absolute zero!

try:
    t.fahrenheit = 100  # AttributeError: no setter defined
except AttributeError as e:
    print(e)  # property 'fahrenheit' of 'Temperature' object has no setter

del t.celsius  # calls deleter: "Resetting temperature"
print(t.celsius)  # 0

# Equivalent without decorator syntax:
class Circle:
    def __init__(self, radius):
        self._radius = radius

    def _get_radius(self):
        return self._radius

    def _set_radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

    radius = property(_get_radius, _set_radius)

100
212.0
25
Temperature below absolute zero!
property 'fahrenheit' of 'Temperature' object has no setter
Resetting temperature
0

Key Points

•@property creates a read-only attribute from a method
•@name.setter and @name.deleter add write and delete support
•Provides validation while keeping attribute-style access
•property is a descriptor class with __get__, __set__, __delete__

Gotchas

•Without a setter, assigning raises AttributeError -- the property is read-only by default
•The internal attribute should use a different name (convention: prefix with _) to avoid infinite recursion
•Properties add method call overhead -- avoid for performance-critical hot paths
•Properties do not work on instances if defined in __init__ -- they must be class-level

@property turns a method into a read-only attribute. Add @name.setter for write access. It provides validation and computed attributes with clean syntax.

•@property for getter, @name.setter for setter
•Use different name for internal storage (prefix with _)

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Negative radius")
        self._radius = value

    @property
    def area(self):
        import math
        return math.pi * self._radius ** 2

c = Circle(5)
print(c.radius)  # 5
print(c.area)    # 78.539...
c.radius = 10    # uses setter

5
78.53981633974483

Setting a property without a setter raises AttributeError

Question 8 / 15

What is the difference between `@staticmethod` and `@classmethod`?

@staticmethod and @classmethod are built-in decorators that change how a method receives its first argument.

@staticmethod: Does not receive any implicit first argument. It behaves like a regular function but lives in the class's namespace. Use it for utility functions logically related to the class but that don't need access to instance or class state.

@classmethod: Receives the class (cls) as its first argument instead of an instance. The key advantage is that cls refers to the class the method was called on, which matters with inheritance. Use it for alternative constructors and factory methods.

Regular instance method: Receives the instance (self) as its first argument.

Key difference in inheritance: @classmethod respects the actual class at call time, so subclasses get their own class as cls. @staticmethod has no class awareness at all.

Pseudo Code

1. Regular method: def method(self) -- receives instance
2. @classmethod: def method(cls) -- receives class
3. @staticmethod: def method() -- receives nothing implicit
4. classmethod is polymorphic (cls changes with inheritance)
5. staticmethod is just a namespaced function

Code

from datetime import datetime

class Employee:
    raise_amount = 1.04  # class variable

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    # Regular instance method
    def apply_raise(self):
        self.salary = int(self.salary * self.raise_amount)

    # Class method -- alternative constructor
    @classmethod
    def from_string(cls, emp_str):
        """Create Employee from 'name-salary' string."""
        name, salary = emp_str.split("-")
        return cls(name, int(salary))  # uses cls, not Employee

    @classmethod
    def set_raise_amount(cls, amount):
        """Modify class variable through classmethod."""
        cls.raise_amount = amount

    # Static method -- utility function
    @staticmethod
    def is_workday(day):
        """Check if a given day is a workday."""
        return day.weekday() < 5

# Usage
emp = Employee.from_string("Alice-75000")  # classmethod as constructor
print(emp.name, emp.salary)  # Alice 75000

print(Employee.is_workday(datetime(2024, 1, 15)))  # True (Monday)

# Inheritance behavior -- this is the key difference
class Manager(Employee):
    raise_amount = 1.10

# classmethod returns the correct subclass
mgr = Manager.from_string("Bob-90000")
print(type(mgr))  # <class 'Manager'> -- cls was Manager!
print(mgr.raise_amount)  # 1.10

# staticmethod has no class awareness
print(Manager.is_workday(datetime(2024, 1, 15)))  # True -- same behavior

Alice 75000
True
<class '__main__.Manager'>
1.1
True

Key Points

•@classmethod receives cls (the class), @staticmethod receives nothing implicit
•Use @classmethod for alternative constructors -- cls ensures correct subclass is created
•Use @staticmethod for utility functions that belong logically to the class
•@classmethod is polymorphic through inheritance; @staticmethod is not

Gotchas

•Using Employee() instead of cls() in a classmethod breaks inheritance -- subclasses would get Employee instances
•@staticmethod cannot access or modify class state -- if you need cls, use @classmethod
•Overusing @staticmethod may indicate the function should just be a module-level function

@classmethod receives cls (the class) and is used for alternative constructors. @staticmethod receives no implicit argument and is a utility function namespaced in the class.

•@classmethod gets cls, @staticmethod gets nothing implicit
•@classmethod for constructors, @staticmethod for utilities

class Date:
    def __init__(self, year, month, day):
        self.year, self.month, self.day = year, month, day

    @classmethod
    def from_string(cls, date_str):
        y, m, d = map(int, date_str.split("-"))
        return cls(y, m, d)  # works with subclasses too

    @staticmethod
    def is_valid(date_str):
        parts = date_str.split("-")
        return len(parts) == 3 and all(p.isdigit() for p in parts)

d = Date.from_string("2024-01-15")
print(Date.is_valid("2024-01-15"))  # True

True

In @classmethod, use cls() not ClassName() to support inheritance

Question 9 / 15

How do you create a class-based decorator in Python?

A class-based decorator uses a class with a __call__ method instead of nested functions. The class's __init__ receives either the function being decorated (for simple decorators) or parameters (for parameterized decorators), and __call__ acts as the wrapper.

Advantages of class-based decorators:

More readable for complex decorators with lots of state
Easier to test (you can inspect the decorator instance)
Can use inheritance to create decorator families
Natural place for instance state between calls

There are two patterns:

Simple: __init__ takes the function, __call__ is the wrapper
Parameterized: __init__ takes parameters, __call__ takes the function and returns a wrapper

Pseudo Code

Simple class decorator:
1. __init__(self, func) -- store the function
2. __call__(self, *args, **kwargs) -- wrap and call func

Parameterized class decorator:
1. __init__(self, param1, param2) -- store parameters
2. __call__(self, func) -- return a wrapper function

Code

import functools

# Simple class-based decorator
class CountCalls:
    """Track how many times a function is called."""

    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.call_count = 0

    def __call__(self, *args, **kwargs):
        self.call_count += 1
        print(f"{self.func.__name__} called {self.call_count} times")
        return self.func(*args, **kwargs)

@CountCalls
def say_hello(name):
    return f"Hello, {name}!"

print(say_hello("Alice"))  # say_hello called 1 times\nHello, Alice!
print(say_hello("Bob"))    # say_hello called 2 times\nHello, Bob!
print(say_hello.call_count)  # 2 -- accessible state!

# Parameterized class-based decorator
class Retry:
    """Retry a function on failure."""

    def __init__(self, max_attempts=3, exceptions=(Exception,)):
        self.max_attempts = max_attempts
        self.exceptions = exceptions

    def __call__(self, func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, self.max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except self.exceptions as e:
                    if attempt == self.max_attempts:
                        raise
                    print(f"Attempt {attempt} failed: {e}")
        return wrapper

@Retry(max_attempts=3, exceptions=(ValueError, ConnectionError))
def fetch_data():
    import random
    if random.random() < 0.5:
        raise ConnectionError("Timeout")
    return {"data": "ok"}

# Class decorator that decorates a class (not a function)
class Singleton:
    """Ensure a class only has one instance."""

    def __init__(self, cls):
        self._cls = cls
        self._instance = None

    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = self._cls(*args, **kwargs)
        return self._instance

@Singleton
class Database:
    def __init__(self, url):
        self.url = url

db1 = Database("sqlite:///test.db")
db2 = Database("postgres://other")
print(db1 is db2)  # True -- same instance

say_hello called 1 times
Hello, Alice!
say_hello called 2 times
Hello, Bob!
2
True

Key Points

•Simple: __init__ takes func, __call__ is the wrapper
•Parameterized: __init__ takes params, __call__ takes func and returns wrapper
•Use functools.update_wrapper(self, func) to preserve metadata
•Class decorators can maintain state between calls naturally

Gotchas

•Simple class decorators don't work as instance methods (self is the decorator, not the object)
•Use functools.update_wrapper instead of @functools.wraps for class decorators
•For method decoration, you may need to implement __get__ for the descriptor protocol

A class with __call__ can be a decorator. __init__ stores the function (or parameters), and __call__ wraps invocations. Class decorators naturally hold state between calls.

•__init__ stores function, __call__ wraps it
•State is naturally available as instance attributes

import functools

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.func(*args, **kwargs)

@CountCalls
def greet(name):
    return f"Hello, {name}"

greet("Alice")
greet("Bob")
print(greet.count)  # 2

Simple class decorators don't work well as instance methods without __get__

Question 10 / 15

How does `functools.lru_cache` work, and when should you use it?

functools.lru_cache is a decorator that memoizes function results using a Least Recently Used (LRU) eviction strategy. It stores results keyed by the function's arguments, so repeated calls with the same arguments return cached results instantly.

How it works:

First call with new arguments: function executes, result is cached
Subsequent calls with same arguments: cached result is returned
When cache reaches maxsize, the least recently used entry is evicted
maxsize=None means unlimited cache (simple memoization)

Cache info: The decorated function gains a cache_info() method returning hits, misses, maxsize, and currsize. cache_clear() empties the cache.

Requirements: All arguments must be hashable (since they're used as dictionary keys). Lists, dicts, and sets cannot be arguments.

Python 3.9+ also provides @functools.cache as a shorthand for @lru_cache(maxsize=None).

Pseudo Code

1. Apply @lru_cache(maxsize=128) to a pure function
2. First call: compute result, store in cache dict
3. Subsequent calls with same args: return cached result
4. Cache full: evict least recently used entry
5. Use cache_info() to monitor hit/miss ratio
6. Use cache_clear() to reset the cache

Code

from functools import lru_cache
import time

# Basic usage -- Fibonacci without caching is exponential
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

start = time.perf_counter()
result = fibonacci(100)
elapsed = time.perf_counter() - start
print(f"fib(100) = {result}")  # 354224848179261915075
print(f"Time: {elapsed:.6f}s")  # nearly instant
print(fibonacci.cache_info())
# CacheInfo(hits=98, misses=101, maxsize=128, currsize=101)

# Unlimited cache (memoization)
@lru_cache(maxsize=None)
def factorial(n):
    return 1 if n < 2 else n * factorial(n - 1)

print(factorial(10))  # 3628800

# Python 3.9+ shorthand
from functools import cache  # same as lru_cache(maxsize=None)

@cache
def expensive_compute(x, y):
    time.sleep(0.1)  # simulate expensive work
    return x ** y

expensive_compute(2, 10)  # slow (first call)
expensive_compute(2, 10)  # instant (cached)

# Practical example: API call caching
@lru_cache(maxsize=256)
def get_user_permissions(user_id: int, resource: str) -> tuple:
    # In real code, this would query a database
    print(f"Fetching permissions for user {user_id}")
    return ("read", "write")

get_user_permissions(1, "doc")  # Fetching permissions...
get_user_permissions(1, "doc")  # cached, no print

# Clearing and inspecting cache
print(get_user_permissions.cache_info())
get_user_permissions.cache_clear()
print(get_user_permissions.cache_info())
# CacheInfo(hits=0, misses=0, maxsize=256, currsize=0)

fib(100) = 354224848179261915075
Time: 0.000053s
CacheInfo(hits=98, misses=101, maxsize=128, currsize=101)
3628800
Fetching permissions for user 1
CacheInfo(hits=1, misses=1, maxsize=256, currsize=1)
CacheInfo(hits=0, misses=0, maxsize=256, currsize=0)

Key Points

•Caches results by arguments using LRU eviction strategy
•maxsize=None for unlimited cache, maxsize=128 is default
•cache_info() shows hits/misses, cache_clear() resets
•Arguments must be hashable (no lists, dicts, sets)

Gotchas

•Arguments must be hashable -- passing a list or dict raises TypeError
•Caching methods on instances can cause memory leaks (the instance is part of the cache key via self)
•Not suitable for functions with side effects or time-dependent results
•Cache persists for the lifetime of the process -- use cache_clear() or set appropriate maxsize

lru_cache memoizes function results by arguments. Repeated calls with same args return cached results instantly. Uses LRU eviction when cache is full.

•Memoizes results by hashable arguments
•cache_info() for stats, cache_clear() to reset

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(50))  # 12586269025 (instant)
print(fibonacci.cache_info())  # hits=48, misses=51

12586269025
CacheInfo(hits=48, misses=51, maxsize=128, currsize=51)

Arguments must be hashable -- no lists or dicts Caching methods causes memory leaks because self is part of the key

Question 11 / 15

What is a decorator factory, and how does it differ from a regular decorator?

A decorator factory is a function that returns a decorator. It adds one extra layer of nesting compared to a regular decorator, allowing you to pass configuration parameters.

Regular decorator: Takes a function, returns a wrapper. Used as @decorator. Decorator factory: Takes parameters, returns a decorator that takes a function and returns a wrapper. Used as @factory(params).

A common advanced pattern is making the parentheses optional, so the decorator works both as @decorator and @decorator(args). This is done by checking whether the first argument is callable (a function) or a parameter.

Pseudo Code

Regular decorator:
  decorator(func) -> wrapper

Decorator factory:
  factory(params) -> decorator(func) -> wrapper

Optional parentheses pattern:
  Check if first argument is callable
  If yes: it's used as @decorator (no parens)
  If no: it's used as @decorator(args) (with parens)

Code

import functools

# Regular decorator -- no configuration
def simple_log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@simple_log  # no parentheses
def add(a, b):
    return a + b

# Decorator factory -- configurable
def log(level="INFO"):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print(f"[{level}] Calling {func.__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log(level="DEBUG")  # parentheses required
def subtract(a, b):
    return a - b

# Advanced: optional parentheses pattern
def smart_log(_func=None, *, level="INFO"):
    """Works as both @smart_log and @smart_log(level='DEBUG')."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print(f"[{level}] Calling {func.__name__}")
            return func(*args, **kwargs)
        return wrapper

    if _func is not None:
        # Called without parentheses: @smart_log
        return decorator(_func)
    else:
        # Called with parentheses: @smart_log(level='DEBUG')
        return decorator

@smart_log
def multiply(a, b):
    return a * b

@smart_log(level="DEBUG")
def divide(a, b):
    return a / b

multiply(3, 4)  # [INFO] Calling multiply
divide(10, 2)   # [DEBUG] Calling divide

[INFO] Calling multiply
[DEBUG] Calling divide

Key Points

•A decorator factory returns a decorator; a regular decorator returns a wrapper
•Factories enable configurable, reusable decorator behavior
•The optional-parentheses pattern uses _func=None with keyword-only args
•factory(params)(func) vs decorator(func) is the structural difference

Gotchas

•Confusing @decorator with @decorator() -- the latter calls the factory with no args
•The optional-parentheses pattern requires all config params to be keyword-only (after *)
•Three levels of nesting can be hard to debug -- consider class-based decorators for complex cases

A decorator factory is a function that takes parameters and returns a decorator. A regular decorator takes a function directly. Use factories when you need configurable decorators.

•Factory returns a decorator; decorator returns a wrapper
•Adds one extra nesting level for configuration

import functools

# Decorator factory
def repeat(n=2):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(n=3)
def hello():
    print("Hello!")

hello()  # prints Hello! three times

Hello!
Hello!
Hello!

@repeat vs @repeat() -- without parens, the function is passed as n

Question 12 / 15

How do you write a decorator that works on both functions and methods?

A decorator that uses *args, **kwargs and @functools.wraps generally works on both regular functions and methods without modification. When a decorated method is called on an instance, Python's descriptor protocol automatically passes the instance as the first argument (self), which gets captured by *args.

However, class-based decorators (using __call__) do NOT work as method decorators by default because they are not descriptors. The instance (self of the class being decorated) is not automatically passed. To fix this, implement the __get__ method on the decorator class to make it a descriptor.

The key insight is that function-based decorators work because functions are already descriptors (they have a __get__ method), and @functools.wraps preserves this. Class-based decorators need __get__ added explicitly.

Pseudo Code

Function-based decorator:
1. Use *args, **kwargs -- self is captured automatically
2. Use @functools.wraps -- preserves __get__ descriptor
3. Works on both functions and methods out of the box

Class-based decorator (needs fix):
1. Implement __get__(self, obj, objtype) on the decorator
2. __get__ returns a partial binding self.__call__ to the instance
3. This makes the descriptor protocol work for methods

Code

import functools
from types import MethodType

# Function-based decorator -- works on both automatically
def log_call(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
        return func(*args, **kwargs)
    return wrapper

# Works as a function decorator
@log_call
def add(a, b):
    return a + b

add(1, 2)  # Calling add with args=(1, 2), kwargs={}

# Works as a method decorator too
class Calculator:
    @log_call
    def multiply(self, a, b):
        return a * b

calc = Calculator()
calc.multiply(3, 4)  # Calling multiply with args=(<Calculator>, 3, 4), kwargs={}

# Class-based decorator -- BROKEN as method decorator
class CountCallsBroken:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.func(*args, **kwargs)

# Class-based decorator -- FIXED with __get__
class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.func(*args, **kwargs)

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        # Bind self.__call__ to the instance
        return MethodType(self, obj)

class MyClass:
    @CountCalls
    def greet(self, name):
        return f"Hello, {name}"

obj = MyClass()
print(obj.greet("Alice"))  # Hello, Alice
print(obj.greet("Bob"))    # Hello, Bob

Calling add with args=(1, 2), kwargs={}
Calling multiply with args=(<__main__.Calculator object at <address>>, 3, 4), kwargs={}
Hello, Alice
Hello, Bob

Key Points

•Function-based decorators with *args, **kwargs work on methods automatically
•@functools.wraps preserves the descriptor protocol (__get__)
•Class-based decorators need __get__ to work as method decorators
•__get__ should return MethodType(self, obj) to bind the instance

Gotchas

•Class-based decorators without __get__ silently fail -- self of the class is not passed
•Be careful with instance state in class decorators shared across all instances of the decorated class
•Using MethodType requires importing from types module

Function-based decorators using *args, **kwargs and @functools.wraps work on both functions and methods automatically. Class-based decorators need a __get__ method to work on methods.

•Function-based decorators work on methods out of the box
•Class-based decorators need __get__ for the descriptor protocol

import functools
from types import MethodType

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.func(*args, **kwargs)

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return MethodType(self, obj)

Without __get__, class-based decorators silently lose the instance (self)

Question 13 / 15

What are some common real-world decorator patterns in Python?

Decorators are used extensively in Python for cross-cutting concerns. Here are the most common real-world patterns:

Authentication/Authorization: Check user permissions before executing a view function (Flask, Django)
Logging: Log function calls, arguments, and return values
Timing/Performance: Measure execution time
Caching/Memoization: Cache expensive function results
Retry with backoff: Retry failed operations with exponential backoff
Rate limiting: Throttle function calls
Input validation: Validate function arguments
Singleton: Ensure only one instance of a class
Deprecation warnings: Warn when deprecated functions are called
Type checking: Runtime type enforcement at function boundaries

Pseudo Code

Common patterns:
1. Auth: check credentials -> allow/deny
2. Retry: loop N times with backoff on exception
3. Validate: check args before calling function
4. Deprecate: emit warning, then call function
5. Rate limit: track calls per time window

Code

import functools
import time
import warnings

# 1. Retry with exponential backoff
def retry(max_attempts=3, backoff_factor=2, exceptions=(Exception,)):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            delay = 1
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    if attempt == max_attempts:
                        raise
                    print(f"Attempt {attempt} failed, retrying in {delay}s...")
                    time.sleep(delay)
                    delay *= backoff_factor
        return wrapper
    return decorator

# 2. Deprecation warning
def deprecated(reason=""):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            msg = f"{func.__name__} is deprecated."
            if reason:
                msg += f" {reason}"
            warnings.warn(msg, DeprecationWarning, stacklevel=2)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@deprecated("Use new_function() instead.")
def old_function():
    return "old result"

# 3. Input validation
def validate_types(**expected_types):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            import inspect
            sig = inspect.signature(func)
            bound = sig.bind(*args, **kwargs)
            bound.apply_defaults()
            for param, expected_type in expected_types.items():
                value = bound.arguments.get(param)
                if value is not None and not isinstance(value, expected_type):
                    raise TypeError(
                        f"{param} must be {expected_type.__name__}, "
                        f"got {type(value).__name__}"
                    )
            return func(*args, **kwargs)
        return wrapper
    return decorator

@validate_types(name=str, age=int)
def create_user(name, age):
    return {"name": name, "age": age}

print(create_user("Alice", 30))  # {'name': 'Alice', 'age': 30}
try:
    create_user("Alice", "thirty")  # TypeError!
except TypeError as e:
    print(e)  # age must be int, got str

# 4. Singleton pattern
def singleton(cls):
    instances = {}
    @functools.wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class AppConfig:
    def __init__(self):
        self.settings = {}

c1 = AppConfig()
c2 = AppConfig()
print(c1 is c2)  # True

# 5. Rate limiter
def rate_limit(calls_per_second=1):
    min_interval = 1.0 / calls_per_second
    def decorator(func):
        last_called = [0.0]
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            elapsed = time.time() - last_called[0]
            if elapsed < min_interval:
                time.sleep(min_interval - elapsed)
            last_called[0] = time.time()
            return func(*args, **kwargs)
        return wrapper
    return decorator

{'name': 'Alice', 'age': 30}
age must be int, got str
True

Key Points

•Retry with backoff for unreliable operations (network, APIs)
•Deprecation warnings guide users to updated interfaces
•Input validation decorators enforce contracts at function boundaries
•Singleton decorator ensures single instance per class

Gotchas

•Rate limiters using time.sleep block the thread -- use async-aware versions in async code
•Singleton decorators replace the class with a function, breaking isinstance checks
•Retry decorators should only catch specific exceptions, never bare except

Common decorator patterns include retry with backoff, deprecation warnings, input validation, singleton, rate limiting, authentication, and caching. They handle cross-cutting concerns cleanly.

•Retry, deprecation, validation, singleton, rate limiting
•Decorators separate cross-cutting concerns from business logic

import functools
import warnings

# Deprecation warning decorator
def deprecated(reason):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            warnings.warn(f"{func.__name__}: {reason}",
                          DeprecationWarning, stacklevel=2)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@deprecated("Use new_api() instead")
def old_api():
    return "result"

Singleton decorators break isinstance checks Retry should only catch specific exceptions

Question 14 / 15

How do you preserve the original function's signature in a decorator?

When you wrap a function with *args, **kwargs, introspection tools like inspect.signature() and help() show the generic signature instead of the original. @functools.wraps partially addresses this by copying __wrapped__, which inspect.signature() follows to display the correct signature.

However, there are cases where @functools.wraps alone is not enough:

When you need the actual parameters available in the wrapper
When frameworks inspect signatures directly (some validation frameworks)
When you need runtime enforcement of the original signature

For full signature preservation, you can use inspect.signature().bind() inside the wrapper to validate arguments against the original function's signature. The makefun or decorator third-party libraries can also create wrappers with exact matching signatures.

Pseudo Code

1. @functools.wraps copies __wrapped__ for inspect.signature()
2. inspect.signature() follows __wrapped__ to show original params
3. For runtime enforcement: use sig.bind(*args, **kwargs) in wrapper
4. For IDE support: functools.wraps is usually sufficient
5. For exact signature: use the 'decorator' or 'makefun' library

Code

import functools
import inspect

# functools.wraps preserves signature for inspection
def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet(name: str, greeting: str = "Hello") -> str:
    """Greet someone."""
    return f"{greeting}, {name}!"

# inspect.signature follows __wrapped__
sig = inspect.signature(greet)
print(sig)  # (name: str, greeting: str = 'Hello') -> str

# Validate arguments in the wrapper using bind()
def strict_decorator(func):
    sig = inspect.signature(func)

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # This will raise TypeError for invalid arguments
        bound = sig.bind(*args, **kwargs)
        bound.apply_defaults()
        print(f"Validated args: {dict(bound.arguments)}")
        return func(*args, **kwargs)
    return wrapper

@strict_decorator
def create_user(name: str, age: int, role: str = "viewer"):
    return {"name": name, "age": age, "role": role}

print(create_user("Alice", 30))
# Validated args: {'name': 'Alice', 'age': 30, 'role': 'viewer'}
# {'name': 'Alice', 'age': 30, 'role': 'viewer'}

try:
    create_user("Alice", 30, "admin", "extra")  # Too many args
except TypeError as e:
    print(e)  # too many positional arguments

# Accessing parameters programmatically
for param_name, param in sig.parameters.items():
    print(f"{param_name}: default={param.default}, kind={param.kind.name}")
# name: default=<class 'inspect._empty'>, kind=POSITIONAL_OR_KEYWORD
# age: default=<class 'inspect._empty'>, kind=POSITIONAL_OR_KEYWORD
# role: default=viewer, kind=POSITIONAL_OR_KEYWORD

(name: str, greeting: str = 'Hello') -> str
Validated args: {'name': 'Alice', 'age': 30, 'role': 'viewer'}
{'name': 'Alice', 'age': 30, 'role': 'viewer'}
too many positional arguments
name: default=<class 'inspect._empty'>, kind=POSITIONAL_OR_KEYWORD
greeting: default=Hello, kind=POSITIONAL_OR_KEYWORD

Key Points

•@functools.wraps sets __wrapped__ which inspect.signature() follows
•Use sig.bind() in wrappers for runtime argument validation
•inspect.signature() shows the original function's parameters, not *args/**kwargs
•Type annotations are preserved through __annotations__ and __wrapped__

Gotchas

•Some older tools may not follow __wrapped__ and show *args, **kwargs instead
•sig.bind() raises TypeError for invalid args -- good for validation, bad if you want flexibility
•@functools.wraps does not create an actual function with the original signature -- it only copies metadata

@functools.wraps sets __wrapped__, which inspect.signature() follows to display the original signature. For runtime validation, use inspect.signature(func).bind(*args, **kwargs) in the wrapper.

•@functools.wraps preserves signature via __wrapped__
•inspect.signature() follows __wrapped__ automatically

import functools
import inspect

def my_deco(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@my_deco
def add(a: int, b: int) -> int:
    return a + b

print(inspect.signature(add))  # (a: int, b: int) -> int

(a: int, b: int) -> int

The wrapper's actual signature is still *args, **kwargs -- only introspection is fixed

Question 15 / 15

How do you use decorators to implement the Singleton pattern in Python?

A Singleton ensures only one instance of a class exists. A decorator-based Singleton is one of the cleanest approaches in Python. The decorator intercepts class instantiation and returns the cached instance on subsequent calls.

There are several approaches:

Function decorator with dict: Store instances in a dictionary keyed by class
Class decorator: Use a class with __call__ and __get__
Thread-safe variant: Use a lock to prevent race conditions

Each has trade-offs. The function decorator is simplest but breaks isinstance checks (since the class is replaced by a function). The __new__-based approach preserves the class identity but is harder to test. The decorator approach is the most Pythonic for most use cases.

Pseudo Code

1. Create a decorator that takes a class
2. Maintain a dictionary of instances
3. On each call, check if an instance exists
4. If not, create one and store it
5. Return the stored instance
6. For thread safety, add a threading.Lock

Code

import functools
import threading

# Simple function-based singleton decorator
def singleton(cls):
    instances = {}

    @functools.wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class Database:
    def __init__(self, url):
        self.url = url
        print(f"Connecting to {url}")

db1 = Database("sqlite:///app.db")  # Connecting to sqlite:///app.db
db2 = Database("postgres://other")  # No output -- returns cached
print(db1 is db2)  # True
print(db1.url)     # sqlite:///app.db

# Thread-safe singleton decorator
def thread_safe_singleton(cls):
    instances = {}
    lock = threading.Lock()

    @functools.wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            with lock:
                # Double-check locking
                if cls not in instances:
                    instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@thread_safe_singleton
class AppConfig:
    def __init__(self):
        self.settings = {}

    def set(self, key, value):
        self.settings[key] = value

    def get(self, key, default=None):
        return self.settings.get(key, default)

config = AppConfig()
config.set("debug", True)

config2 = AppConfig()
print(config2.get("debug"))  # True -- same instance

# Note: isinstance is broken with function-based approach
# print(isinstance(config, AppConfig))  # TypeError

# To preserve isinstance, use __new__ instead:
class SingletonMeta(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Logger(metaclass=SingletonMeta):
    def __init__(self):
        self.messages = []

log1 = Logger()
log2 = Logger()
print(log1 is log2)  # True
print(isinstance(log1, Logger))  # True -- works!

Connecting to sqlite:///app.db
True
sqlite:///app.db
True
True
True

Key Points

•Decorator stores instances in a dict and returns cached one on subsequent calls
•Thread-safe version uses double-check locking with threading.Lock
•Function decorator is simplest but breaks isinstance
•Metaclass approach preserves isinstance compatibility

Gotchas

•Function-based singleton breaks isinstance(obj, ClassName)
•Constructor arguments are ignored after the first call -- the first args win
•Without thread safety, concurrent calls can create multiple instances
•Singletons make testing harder -- consider dependency injection instead

A singleton decorator caches the first instance of a class and returns it for all subsequent calls. Use a dict to store instances, and a lock for thread safety.

•Cache first instance, return it for all subsequent calls
•Add threading.Lock for thread safety

import functools

def singleton(cls):
    instances = {}
    @functools.wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class Config:
    def __init__(self):
        self.data = {}

c1 = Config()
c2 = Config()
print(c1 is c2)  # True

True

Function-based singleton breaks isinstance checks Constructor args are ignored after first instantiation

Built by onllm.dev

Home GitHub Support awesomePrep