What are some examples of decorators in Python 3.10?

What are some examples of decorators in Python 3.10?

In Python 3.10, decorators are a powerful tool for modifying functions or methods. Here are a few examples:

1. Simple Decorator: A basic decorator that prints a message before and after a function call.

def my_decorator(func):
    def wrapper():
        print("Before the function call")
        func()
        print("After the function call")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

2. Decorator with Arguments: A decorator that takes arguments to customize its behavior.

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

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

greet("Alice")

3. Class Method Decorator: Using decorators with class methods.

class MyClass:
    @classmethod
    def class_method(cls):
        print("This is a class method")

MyClass.class_method()

These examples illustrate how decorators can enhance functionality in Python 3.10.

Can you explain how the functools.wraps decorator works?

Certainly! The functools.wraps decorator is used to preserve the metadata of the original function when you create a decorator. When you define a wrapper function inside your decorator, it typically loses the original function's name, docstring, and other attributes. By using functools.wraps, you can ensure that the wrapper function retains these properties.

Here's an example:

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Before the function call")
        result = func(*args, **kwargs)
        print("After the function call")
        return result
    return wrapper

@my_decorator
def say_hello():
    """This function says hello."""
    print("Hello!")

print(say_hello.__name__)  # Output: say_hello
print(say_hello.__doc__)   # Output: This function says hello.

In this example, @wraps(func) ensures that say_hello retains its name and docstring even after being decorated.

What are some common use cases for decorators?

Common use cases for decorators include:

1. Logging: Automatically log function calls, arguments, and return values.
2. Access Control: Restrict access to certain functions based on user permissions.
3. Caching: Store results of expensive function calls to improve performance on subsequent calls.
4. Timing: Measure the execution time of functions for performance analysis.
5. Validation: Validate input parameters before executing a function.