Summary  
This chapter covers how to build parameterized decorators by using a decorator factory that returns a decorator, allowing the wrapper to access both the decorator’s arguments and the decorated function’s parameters to modify its behavior.

General domain of usage  
Logging

Decorators with parameters in Python are an advanced feature that allow you to pass additional arguments to your decorators, enhancing their flexibility. Here's a practical example to illustrate this concept:

### Basic Decorator Structure
First, let's start with a basic decorator structure:

def simple_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

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

say_hello()

In this example, *simple_decorator* is a **regular decorator** that modifies the behavior of the *say_hello* function.

### Decorator with Parameters
Now, let's create a decorator that accepts parameters:

def decorator_with_args(arg1, arg2):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"Decorator args: {arg1}, {arg2}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@decorator_with_args("hello", 42)
def print_numbers(a, b):
    print(a + b)

print_numbers(10, 5)

In this example, `decorator_with_args` is a **decorator factory** that accepts parameters *(arg1, arg2)* and returns the actual decorator *(decorator)*. The *wrapper* function is the one that *modifies the behavior* of the *decorated function* (print_numbers).
#### Explanation
* `decorator_with_args` is called with its arguments `("hello", 42)`;
* It returns the `decorator` function;
* `decorator` takes a function `print_numbers` and returns the `wrapper` function;
* `wrapper` has access to both the arguments of `decorator_with_args` and the arguments of `print_numbers`.

This structure allows for greater flexibility and reusability of decorators, as you can pass custom arguments to modify their behavior.

In this course, you will learn advanced topics such as function arguments, iterators, generators, closures, and decorators. Dozens of practice exercises will help you grasp these topics.

You'll find this topic enjoyable, and you'll learn how to pack and unpack values in a single assignment.

Explore the power of Python's function arguments, *args, **kwargs, and learn how to effectively use functions as arguments.

Discover the higher-order functions and how functions can be passed as arguments to other functions in programming.

What is variable scope, and how did we manage without it before? This topic is essential for understanding the following subjects: Closures and Decorators. I assure you that this topic will be both enjoyable and practical. You will gain knowledge about local, nonlocal, and global variables.

This section provides an in-depth exploration of Python decorators, a powerful feature that allows for the modification and enhancement of function behavior. Participants will learn how to write their own decorators, understand built-in decorators, and apply decorators in practical scenarios.

Using Decorators with Parameters in Python

Basic Decorator Structure

Decorator with Parameters

Explanation