There are situations where decorators need to take parameters to modify their behavior. For instance, in the previous **Task**, you implemented the `int_validate()` decorator to validate integer inputs, but what if you need to validate other data types as well?

In such cases, you can modify the decorator to accept parameters that specify the data type to validate. But before that, let's first understand how parameters work in decorators.

# Implementation
To use parameters in a decorator, you need to create an additional layer of non-local scope.

|**Ordinary Decorator**| **Decorator with Parameters**|
| --- | --- |
|| First outer function (for parameter closure)
| Outer function (for function closure).| Second outer function (for function closure).
| Inner function (function wrapper). | Inner function (function wrapper).

def decorator(param1, param2):
    def inner(func):
        def wrapper(*args):
            print("Parameters:", param1, param2)
            return func(*args)
        return wrapper
    return inner


@decorator("First", "Second")
def add(a, b):
    return a + b
  
print(add(25, 13))

In the example above, the `decorator()` function takes two parameters (`param1` and `param2`) and returns the `inner()` function with enclosed parameters. After, the inner() function is used as an ordinary decorator.

> Note
>
> The `decorator()` function returns the `inner() function, enclosing the parameters in it. The returned `inner()` function becomes a new decorator with closed parameters and is then applied to the function you need to be decorated.

How it works in code:
```python
# Step 1
@decorator("First", "Second")
def add(a, b):
    return a + b

# Step 2
@inner  # returned inner with enclosed parameters
def add(a, b):
    return a + b
```

> Note
>
> The second parentheses `()` are the call of the returned object.

How many functions do you need to define a ordinary decorator?

How many functions do you need to define a decorator with parameters?

Discover the secrets of Python's Scopes, Closure, and Decorators in this immersive course. Gain mastery over variable visibility, unlock the power of closures for flexible function creation, and learn how decorators can enhance and modify your code dynamically. Elevate your Python skills and unleash the full potential of your programming abilities.

Python code distributes variables and objects across different environments isolated from each other. They are called scops. Let's study them, shall we?

To learn closure, you must complete the previous section, "Scopes".  The closure is used for decorators, caching, and other programming tools.

Decorators are widely used in real development. They open up many possibilities for us, and it is worth knowing how they work. To understand decorators, you need to know scopes and closures.

Step	Ordinary Decorator	Decorator with Parameters
1	add = `decorator(add)`	add = `decorator(param1, param2)(add)`
2	`add = wrapper`	add = `inner(add)`
3		`add = wrapper`

Ordinary Decorator	Decorator with Parameters
	First outer function (for parameter closure)
Outer function (for function closure).	Second outer function (for function closure).
Inner function (function wrapper).	Inner function (function wrapper).

Mastering Python: Closures and Decorators

Decorator with Parameters

Implementation

Steps for applying decorators