The **non-local** scopes are **outer local** scopes. This means that the **non-local** scope is placed between **global** scope and function **local** scope:

def first_outer():
    first = "first_outer() local scope"

    def second_outer():
        second = "second_outer() local scope"

        def inner():
            third = "inner() local scope"

            print("Inner non-local:", first)
            print("Inner non-local:", second)
            print("Inner local:", third)

        inner()

    second_outer()

first_outer()

The `first_outer()` local and `second_outer()` local scope are **non-local** scopes for the `inner()` function.

### Access to change non-local objects
You can change the non-local variable or another object using the `nonlocal` keyword (similar to the `global` keyword):

def outer():
    some_variable = 255

    def inner():
        nonlocal some_variable
        print(some_variable)
        
        some_variable += 233
        print(some_variable)

    inner()

outer()

<details>
  <summary class='CodeD'>Code Description</summary>
  <div class="CodeD-text">
In this code, we have two functions: <code>outer()</code> and <code>inner()</code>. The variable <code>some_variable</code> is defined in the <code>outer()</code> function's local scope. The <code>inner()</code> function is nested inside the <code>outer()</code> function.<br>
<br>
The <code>nonlocal</code> keyword is used inside the <code>inner()</code> function to indicate that the variable <code>some_variable</code> is not a local variable of <code>inner()</code> or global but belongs to its non-local scope (<code>outer()</code> in this case). This allows <code>inner()</code> to access and modify the non-local variable <code>some_variable</code>.<br>
<br>
When we call the <code>inner()</code> function, it prints the value of <code>some_variable</code>, which is <code>255</code>. Then, it increments the value of <code>some_variable</code> by <code>233</code>, resulting in <code>some_variable</code> being <code>488</code>.<br>
<br>
Therefore, the <code>nonlocal</code> keyword allows us to modify non-local variables, just like the <code>global</code> keyword allows us to modify global variables from within a function's local scope.
  </div> 
</details>

> Note
>
> **Why pay attention to non-local scope?**  
The **non-local** scope is used for the **closure**. That's why **non-local** scope is also named **enclosing** scope. The **closure** will be described in the next section.

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

Non-local Scope

Access to change non-local objects