Python Decorators Exercises

The term "Decorator" comes from the Decorator Design Pattern. It allows you to "wrap" an existing piece of code in a new layer of logic.

Think of it like a Gift Wrap:

• The Function is the gift inside.
• The Decorator is the wrapping paper and the bow.
• When you receive the gift, you still get the item inside, but the appearance and presentation have been modified.

While you can apply decorators manually, Python provides the @ symbol to make your code much cleaner and easier to read.

# This syntax:
@my_decorator
def my_function():
    pass

# Is exactly the same as:
def my_function():
    pass
my_function = my_decorator(my_function)

The @ symbol is placed immediately above the function definition you wish to modify.

This is the foundation of all advanced Python features. If functions weren't first-class objects, decorators wouldn't be possible!

What you can do with a function:

• Assignment: say_hi = print -> say_hi("Hello")
• Pass as Argument: You can send a function into another function (this is what decorators do).
• Nested Functions: You can define a function inside another function.

When you decorate a function, you are effectively "swapping" the original function for the wrapper.

The Substitution:

1. The decorator takes the original func.
2. It defines a new function (the wrapper) that calls func() inside it.
3. It returns the wrapper.

From that point on, every time you call the decorated function, you are actually running the wrapper logic!

This is a common bug when writing your first decorator.

Because the decorator replaces your function with the wrapper, if you don't explicitly call func() inside that wrapper, the original code inside your function will simply be skipped. The wrapper has complete control over whether the original function runs at all.

To make a decorator "generic" (able to wrap any function), you must use argument unpacking.

Why *args and **kwargs?

• *args: Captures all positional arguments as a tuple.
• **kwargs: Captures all keyword arguments as a dictionary.

By using wrapper(*args, **kwargs) and then passing them into the original function as func(*args, **kwargs), the decorator acts like a transparent pipe, allowing any data to pass through without needing to know the function's specific signature.

This is the most frequent mistake in intermediate decorator development.

The "Middleman" Rule:

Since the wrapper replaces the original function, the caller (the print statement) is now getting the output of the wrapper, not the original add function.

• Inside the wrapper, result * 2 is calculated, but it is never returned to the caller.
• In Python, a function that doesn't explicitly return something returns None by default.

Correct Fix: return result * 2 inside the wrapper.

This is a standard "Boilerplate" decorator used in performance tuning.

Why Option 1 is correct:

1. It captures the start time.
2. It executes the original function and saves the result.
3. It calculates the difference and prints it.
4. It returns the original result so the rest of the program continues to work normally.

This decorator modifies the output of the function.

Step-by-Step:

• greet() is called, which actually triggers the wrapper.
• The wrapper calls the original greet, which returns "hello".
• The wrapper then applies .upper() and adds "!!!".
• The final result returned to the print statement is "HELLO!!!".

This is a Conditional Execution decorator.

The wrapper acts as a gatekeeper. By using an if/else statement, it decides whether to execute the original func or to skip it and show an error message instead. This is a very common pattern in frameworks like Flask or Django for protecting specific URLs.

Decorators "hide" the original function's metadata (its name, docstring, and argument list). This can break debugging tools and help documentation.

The Solution: functools.wraps

Python provides a built-in decorator for your decorators! By using @wraps(func), Python copies all the original metadata from func onto your wrapper.

from functools import wraps

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

Result: greet.__name__ will correctly return "greet".

Think of stacked decorators like layers of an onion. The one closest to the function definition is applied first.

The Execution Flow:

1. decorator_B wraps my_func.
2. decorator_A then wraps the new function created by decorator_B.

Mathematically, it looks like this: my_func = decorator_A(decorator_B(my_func)).

This requires three levels of nested functions. It can be confusing at first, but it follows a logical structure.

The Structure:

• Level 1 (The Factory): Takes your custom argument (e.g., num_times).
• Level 2 (The Decorator): Takes the func to be decorated.
• Level 3 (The Wrapper): Takes the *args, **kwargs and runs the loop.

def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

To use a class as a decorator, the class instances must be "callable" (they must behave like a function).

The Mechanism:

1. The __init__ method captures the original function.
2. The __call__ method acts as the "wrapper." It is executed every time the decorated function is called.

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

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

This is an excellent way to maintain state (like a counter) across multiple function calls.

This exercise combines Decorator Factories and Stacking.

Step-by-Step Logic:

1. @tag("b") wraps greet, resulting in Hello.
2. @tag("p") wraps the entire result of the first step.
3. Final output: <p><b>Hello</b></p>.

The decorator closest to the function (the bottom one) is the "inner" layer, and the top decorator is the "outer" layer.

This utilizes the power of Closures. A closure occurs when a nested function "remembers" the local variables of its outer function even after the outer function has finished executing.

The 'nonlocal' Keyword:

Inside the wrapper, if you try to do count += 1, Python will think count is a new local variable. By declaring nonlocal count, you tell Python to use the variable from the decorator's scope.

def count_calls(func):
    count = 0
    def wrapper(*args, **kwargs):
        nonlocal count
        count += 1
        print(f"Call {count} of {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

When you decorate an instance method, the first argument passed to the wrapper is always the instance of the class (self).

Why it works:

Since wrapper is defined with *args, when you call obj.do_work(10), args becomes (obj, 10). When the wrapper calls func(*args), it is effectively calling do_work(obj, 10), which is exactly how Python methods work internally!

It is crucial to remember that the @ symbol is just a shortcut. Understanding the manual assignment helps when you need to decorate functions dynamically at runtime.

# The @ symbol does this at the time of definition:
def my_func(): pass
my_func = decorator(my_func)

This means the name my_func no longer points to the original code you wrote; it now points to the wrapper object returned by the decorator.

This is a "pro-level" pattern found in many famous libraries like pytest or click.

The Logic:

• When used as @log, the first argument is the function itself.
• When used as @log(level="DEBUG"), the first argument is the string "DEBUG".

By checking if callable(arg):, your decorator can decide whether to act as a decorator immediately or to return a new decorator that captures the settings.

Class decorators are highly effective for Meta-programming.

Use Cases:

• Singleton Pattern: Ensure only one instance of a class is ever created.
• Attribute Injection: Automatically add new methods or variables to the class.
• Registration: Add the class to a global registry for a plugin system.

Just like function decorators, a class decorator takes the class, modifies it (or wraps it), and returns it.