PCAP Closures and Decorators 2

Question 1

What is a decorator in Python?

Accepted Answer

A callable that takes a function as an argument, extends its behavior, and returns a new callable

Answer

A special comment syntax that annotates function signatures for type checking

Answer

A built-in design pattern that replaces multiple inheritance

Answer

A Python keyword that formats string output

Question 2

What is the `@my_decorator` syntax exactly equivalent to when placed above `def func(): ...`?

Accepted Answer

func = my_decorator(func)

Answer

func = func(my_decorator)

Answer

my_decorator.apply(func)

Answer

func.__decorator__ = my_decorator

Question 3

What does `@functools.wraps(func)` do when applied inside a decorator's wrapper function?

Accepted Answer

Copies the wrapped function's metadata (__name__, __doc__, __module__, etc.) onto the wrapper

Answer

Makes the wrapper function execute faster by bypassing Python's call overhead

Answer

Prevents the decorator from being stacked with other decorators

Answer

Creates a deep copy of the original function's bytecode

Question 4

When the following decorators are applied, in what order are they executed?

@decorator_a
@decorator_b
def func(): pass

Accepted Answer

decorator_b wraps func first (innermost), then decorator_a wraps the result (outermost)

Answer

decorator_a is applied first, then decorator_b is applied to that result

Answer

Both decorators are applied simultaneously in an unspecified order

Answer

The order is determined by each decorator's priority attribute

Question 5

What will `print(greet.__name__)` output?

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

@my_decorator
def greet():
    pass

Accepted Answer

greet

Answer

wrapper

Answer

my_decorator

Answer

None

Question 6

How is a decorator that accepts its own arguments (a parameterized decorator) structured?

Accepted Answer

An outer function accepts the arguments and returns a decorator function that accepts and wraps the target function

Answer

Arguments are passed directly in the @decorator(args) call and the function takes them as *args

Answer

The decorator class uses __init__ to store arguments and __call__ to act as the wrapper directly

Answer

Arguments are attached as attributes on the decorator function before applying it

Question 7

Why should a decorator's wrapper function use `*args, **kwargs` instead of matching the wrapped function's exact signature?

Accepted Answer

So the decorator is generic and can wrap any function regardless of its parameter signature

Answer

To convert all positional arguments into keyword arguments automatically

Answer

To prevent the wrapped function from receiving unintended arguments

Answer

To make the wrapper behave as a generator function