There are different ways to use arguments in closure:
1. Argument for the **outer** function.
2. Argument for the **inner** function.

# Outer Argument
Arguments for the **outer** function is used to enclose the values inside the function exactly once. This works like initialization:

def start_count(start=1, step=1):
    counter = start

    def inner():
        nonlocal counter
        result = counter

        counter += step

        return result

    return inner

first_counter = start_count()
second_counter = start_count(13, 14)

print("First counter:")
print(first_counter())
print(first_counter())

print("Second counter:")
print(second_counter())
print(second_counter())

print("First counter:")
print(first_counter())
print(first_counter())

print("Second counter:")
print(second_counter())
print(second_counter())

The example above implements a counter function. The `start_count()` function takes two arguments: `start` and `step`, with default values of `1`. The `start` value is assigned to the variable `counter`. The `counter` and `step` are then used inside the `inner()` function.

The arguments' values `start` (`counter`) and `step` are enclosed in the inner() function as parameters for the counter.

The variables `first_counter` and `second_counter` contain the `inner()` functions with enclosed parameters. These variables are functions that can be called without parameters.

>Note
>
> The variables `first_counter` and `second_counter` are independent counters: as an example, we can see how each of them has its own separate value and performs certain actions.

# Inner Arguments
The `inner()` function is a returned function assigned to variables. The arguments that the `inner()` takes are used every time the `inner()` function is called via variables.

def hero_hit(hero_name="Unknown"):
    def inner(monster="Unknown"):
        print("The", hero_name, "hero hit the", monster, "monster")
    
    return inner


john = hero_hit("John")  # use the outer argument
john("Goblin")  # use the inner argument

john("Dinosaur")  # inner("Goblin")
john()  # inner()
john("Dragon")  # inner("Dragon")

<details>
 <summary class='CodeD'>Code Description</summary>
 <div class="CodeD-text">
In this code, we have defined two nested functions: <code>hero_hit()</code> and <code>inner()</code>. The <code>hero_hit()</code> function takes an optional argument <code>hero_name</code>, while the <code>inner()</code> function takes an optional argument <code>monster</code>. Let's analyze the code and see how the arguments of the <code>inner()</code> function are utilized: 
 
<ol>
<li>The <code>hero_hit()</code> function:</li>
 - Takes an optional argument <code>hero_name</code> with a default value of "Unknown". 
 - Defines the nested function <code>inner()</code>. 
 
<li>The <code>inner()</code> function:</li>
 - Takes an optional argument <code>monster</code> with a default value of "Unknown". 
 - Prints a message indicating that the hero (given by the <code>hero_name</code> argument) hit the monster (given by the <code>monster</code> argument). 
 
<li>The <code>hero_hit()</code> function returns the <code>inner()</code> function, essentially creating a closure that retains the value of <code>hero_name</code>.</li>
 
<li>We create a closure <code>john</code> by calling <code>hero_hit("John")</code>, which sets the <code>hero_name</code> argument to "John".</li>
 
<li>When we call <code>john("Goblin")</code>, it prints: "The John hero hit the Goblin monster". Here, the <code>hero_name</code> argument comes from the outer function (<code>hero_hit("John")</code>), and the <code>monster</code> argument comes from the inner function call (<code>john("Goblin")</code>).</li>
 
<li>When we call <code>john("Dinosaur")</code>, it behaves the same as the previous call (<code>john("Goblin")</code>), printing: "The John hero hit the Dinosaur monster". Again, the <code>hero_name</code> argument is taken from the outer function, and the <code>monster</code> argument is provided in the inner function call.</li>
 
<li>When we call <code>john()</code>, it behaves as if we had called <code>john("Unknown")</code>, and it prints: "The John hero hit the Unknown monster". Here, since we didn't provide any argument in the inner function call, the <code>monster</code> argument takes its default value of "Unknown".</li>
 
<li>When we call <code>john("Dragon")</code>, it behaves like <code>john("Dragon")</code>, and it prints: "The John hero hit the Dragon monster". The <code>hero_name</code> argument comes from the outer function, and the <code>monster</code> argument comes from the inner function call.</li>
</ol>
 
In summary, the <code>inner()</code> function can take an optional <code>monster</code> argument, which can be provided when calling the <code>john</code> closure. If no <code>monster</code> argument is provided, it uses its default value of "Unknown". The <code>hero_name</code> argument is retained from the outer function (<code>hero_hit()</code>), and it doesn't need to be specified again when calling the <code>john</code> closure. 
 </div> 
</details>

Arguments passed to the `inner()` function behave like **regular function arguments** and are not related to the closure.

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.

Mastering Python: Closures and Decorators

Closure with Arguments

Outer Argument

Inner Arguments