The **scope** is an environment that stores variables, functions, and other objects in a program.

Let's consider the example:

number = 15
print("Regular: number =", number)

def some_function():
    number = 256
    print("Function: number =", number)

some_function()

print("Regular: number =", number)

The `number` variable in the regular code and the `number` in the `some_function` have the same name but are different variables because they are placed in different scopes.

# Scope Types
- Built-in
- Global
- Non-local (Enclosing)
- Local

### Built-in Scope
This is a scope of Python built-in tools. For example, the built-in `len()` function. You can use this function everywhere in your code.

### Global Scope
It's the main scope of your code. This scope contains the variables, functions, and other objects you define.

### Non-local (Enclosing) Scope
The **non-local** scopes are scopes between **global** and **local** scopes. The non-local scope can be enclosed and transformed into the **enclosing** scope. It will be described in the next section.

### Local Scope
This scope is used for functions. Every function has a unique scope that deletes after the function executes.

### How do scopes work?
Let's take a look at an example and analyze it.:

number = 2077
string = "Global scope"

print(len(string))

def add(first, second):
    result = first + second
    return result

print(add(25, 13))
print(result)  # NameError: no `result` variable in the global scope.

<details>
  <summary class='CodeD'>Code Description</summary>
  <div class="CodeD-text">
Inside the function <code>add()</code>, a variable <code>result</code> is defined. This variable has a local scope, meaning it is only accessible within the function and does not exist outside of it.<br>
<br>
When attempting to print the <code>result</code> variable outside the <code>add()</code> function, a <code>NameError</code> is raised. This is because <code>result</code> is a local variable, and it doesn't exist in the global scope.
  </div> 
</details>

Here the **global scope** has the variables `number` and `string` and the `add()` function.  
The `len()` and `print()` functions are used from the **built-in scope**.  
The `add()` function has a **local scope** with the variables `first`, `second`, and `result`. Arguments are variables defined inside the function, and the received data assign to these variables.

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

What are scopes?

Scope Types

Built-in Scope

Global Scope

Non-local (Enclosing) Scope

Local Scope

How do scopes work?