def outer(argument):
    def inner():
        nonlocal argument
        argument += 5

        return argument

    return inner

variable1 = outer(11)
variable2 = outer(9)

print("First variable1 returns", variable1())
print("Second variable1 returns", variable1())

print("First variable2 returns", variable2())
print("Second variable2 returns", variable2())

We can operate with the enclosed data: the `nonlocal` keyword provides the ability to change `argument` (similar to the `global` keyword).

# Steps to create closure

**Step 1:**  
Create the **outer** function with its **local** scope.
```python
def outer():
    a = 4

```

**Step 2:**  
Create an **inner** function with **local scope** defined **inside the outer** function.
```python
def outer():
    a = 4
    
    def inner():

```

**Step 3:**  
**Access the non-local (outer scope) data** from within the **inner local scope**.

```python
def outer():
    a = 4
    
    def inner():
        nonlocal a

```

**Step 4:**  
**Return** the inner function and assign it to the **variable**.

```python
def outer():
    a = 4
    
    def inner():
        nonlocal a

    return inner

variable = outer()
```

**Step 5:**  
The **local scope of the outer function** is removed once it has finished executing.

```python
#def outer():
#    a = 4
#    
    def inner():
        nonlocal a
#
#    return inner

variable = outer()
```

**Step 6:**  
The **inner** function **returned by the outer** function is assigned to the **variable** and has an **enclosing scope** with data.

```python
#def outer():
#    a = 4
#    
    def inner():
        nonlocal a
#
#    return inner

variable = inner
variable()  # is equal to inner()
```

The **enclosing** scope occupies less memory than the **non-local** scope because it contains only the dependent values. Enclosed variables/objects do not have names and are represented as memory addresses.

The **closure** and **enclosing scope** are commonly used in decorators.

> Note
>
> Every time the `outer()` function is called, a new `inner()` function is defined.
>
> The returned `inner()` functions are distinct and independent objects.


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

Implementation of Closure

Steps to create closure