In this lesson, you'll learn about Python scopes. Scope deals with regions of code where certain namespaces are accessible.

Scope

Recall, in Python, namespaces are the backbone of how our programs are stored and retrieved. However, knowing about namespace mechanism isn't enough to explain the following behavior: 

```py
def printColor():
  color = 'red'

print(color)
```

If we run this code, our output would give us: 

```error
NameError: name 'color' is not defined
```

Well, that's puzzling. We can see that there clearly exists a name called `color`, and we know anytime we define a variable it gets added to a namespace, yet we can’t seem to access it! What gives? 

Well, this is where a concept called _scope_ comes into play. Scope defines which namespaces our program will look into (to check names) and in what order. While multiple namespaces usually exist at once, this does not mean we can access all of them in different parts of our program! Exploring the concept of scope will allow us to start recognizing when and where certain objects may or may not be accessed. 

Similar to namespaces, there are four different levels of scope. These levels are: 
1. Built-in Scope (We will skip talking about this scope)
2. Global Scope
3. Enclosing Scope
4. Local Scope

Those four scope names should look very familiar since those are also the four namespaces we talked about! Each of these scopes has a different level of access to the namespaces our programs generate. In the next few exercises, we will examine each of these scopes.

***Note:*** As we explore the ideas around scope, there may be some confusion between what distinguishes the concept of scope and namespaces. While both concepts are interlinked and work together, namespaces are simply the mechanism for storing name-object pairs, while scope will serve as a rule system on where (which point in our code) we can retrieve those names. 

Introduction to Scope

At the highest level of access, we have the _global scope_. Names defined in the global namespace will automatically be globally scoped and can be accessed anywhere in our program. 

For example:
```py
# global scope variable
gravity = 9.8

def get_force(mass):
  return mass * gravity

print(get_force(60))
```

Would output: 
```
588.0
```

However, similar to local scope, values can only be accessed but not modified. For example, if we tried to manipulate the value of `gravity`:
```py
# global scope variable
gravity = 9.8

def get_force(mass):
  gravity += 100
  return mass * gravity

print(get_force(60))
```

Would output: 
```error
UnboundLocalError: local variable 'gravity' referenced before assignment
```

We probably shouldn't be manipulating gravity anyway! Let's practice accessing values in the global scope to get a hang of it.

Global Scope

Let's return to our puzzling example from the previous exercise: 
```py
def favorite_color(): 
  color = 'Red'

print(color) 
```

Whenever we decide to call a function, a new _local scope_ will be generated. Each subsequent function call will generate a new local scope. Since the local scope is the deepest level of the four scopes, names in a local scope cannot be accessed or modified by any code called in outer scopes. As a rule of thumb, any names created in a local namespace are usually also locally scoped. 

In this case, the name of `color` is scoped locally to the function `favorite_color()`. Since the statement `print(color)` is called outside of the function, it has no access to the local scope (and thus the local namespace) inside of `favorite_color()` and returns an error. 

However, if we were to refactor our code: 
```py
def favorite_color(): 
  color = 'Red'
  print(color) 

favorite_color()
```

Then, we wouldn't have trouble accessing the name of `color` since now the `print()` function is scoped locally, and our output would return `'Red'`. 

Let’s take some time to practice the basics of local scope!

Local Scope

Similar to how nested functions form a unique namespace within their enclosing functions (the enclosing namespace), there also exist special rules that apply for accessing nested values. These rules make up the _enclosing scope_ (also known as _nonlocal scope_). Let’s take a look at a nested function to see the scope in action: 

```py
def outer_function():
  enclosing_value = 'Enclosing Value'
 
  def nested_function():
    nested_value = 'Nested Value'
    print(enclosing_value)
  
  nested_function()

outer_function()
```

Our output would be: 
```bash
Enclosing Value
```

Enclosing scope allows any value defined in an enclosing function to be accessed in nested functions below it. We can observe this scope since `nested_function()` can access a variable defined one level above in the enclosing function (`outer_function()`). 

We can also observe this scoping rule further if we nested a function one level deeper: 
```py
def outer_function():
  enclosing_value = 'Enclosing Value'
 
  def nested_function():
    nested_value = 'Nested Value'

    def second_nested():
       print(enclosing_value)
       print(nested_value)

     second_nested() 
  
  nested_function()

outer_function()
```

Would output: 
```bash
Enclosing Value
Nested Value
```

There are two caveats to be aware of with enclosing scope: 
- The flow of scope access only flows upwards. This means that the deepest level has access to every enclosing namespace above it, but not the other way around. For example, if we tried to access `nested_value` from one level above where it was defined: 

  ```py
  def outer_function():
    enclosing_value = 'Enclosing Value'
    print(nested_value)

    def nested_function():
      nested_value = 'Nested Value'

    nested_function()

  outer_function()
  ```

  The program would produce an error: 
  ```Bash
  NameError: name 'nested_value' is not defined
  ```


- Immutable objects, such as strings or numbers, can be accessed in nested functions, but cannot be modified. Let's try to change `enclosing_value` to see this restriction in action: 
  ```py
  def outer_function():
    enclosing_value = 'Enclosing Value'
    
    def nested_function():
      enclosing_value += 'changed'
    
    nested_function()
    print(enclosing_value)

  outer_function()
  ```

  Would output: 
  ```error
  UnboundLocalError: local variable 'enclosing_value' referenced before assignment
  ```

Let's now practice accessing values in the enclosing scope!

Enclosing/Nonlocal Scope

While most of our focus so far has been around where we can access namespaces, to truly get a full picture of scoping rules, we must also examine how Python handles _scope resolution_. 

Scope resolution is a term used to describe a search procedure for a name in the various namespaces. A set of rules dictates the order that the search needs to follow.

In Python, the unofficial rule (often referred to in literature but does not exist in the official documentation) is known as the _LEGB rule_. 

LEGB stands for Local, Enclosing, Global, and Built-in. These four letters represent the order of namespaces Python will check to see if a name exists. Here is a visualization of the order: 


![LEGB Rule](https://static-assets.codecademy.com/Courses/Intermediate-Python/LEGB-Rule.gif)

To see this rule in action, let's take a look at two specific scenarios where Python is searching for a name. The first scenario is a nested function that wants to print a variable called `age`: 


```py
age = 27 

def func(): 

  def inner_func():
    print(age)
  inner_func()

func()
```
Would output: 

```bash
27
```

So what exactly happened here in terms of scope resolution? It went a bit like this: 

- First, Python looked in the local (The L of LEGB) scope that existed inside of `inner_func()`. This is the lowest level of the LEGB rule and thus where Python starts the search for a name that is trying to be called (in this case via a `print()`). Python then realized the name of `age` isn't in the local namespace and continues the search to the upper levels of scope. 

- The second level Python examined is the enclosing scope (The E of LEGB) of `func()`. Unfortunately, again the name of `age` doesn't exist in the enclosing namespace, and Python moves upwards to higher scopes. 

- Next, Python arrives at the global scope and finds the name of `age` in the global namespace. The search is finished, and the result is returned. 

This process of scope resolution is crucial to understanding how programs are able to access names in different scopes. Keep in mind the order that Python searches always start at the lowest level (the local level) and always flows upward to the higher scopes.  

The second scenario to examine is seeing what happens when we have two of the same name in different namespaces. 

Let's examine the same script but with a slight modification that creates a second name called `age` in a different namespace. Here is what it looks like: 

```py
age = 27 

def func(): 
  age = 42

  def inner_func():
    print(age)
  
  inner_func() 

func()
```

Here the output will be `42` because Python could find a name (`age`) in the enclosing scope and did not continue to search for the value up into the global scope. If Python cannot find a name in any of the four scopes it searches, it will return a `NameError` exception. 

Scope Resolution: The LEGB Rule

Great job! You've learned some important concepts in Python regarding scope.

In this lesson, we've covered:
- The concept of scope and the LEGB rule.
- What the local scope is.
- What a nested function is and the enclosing/nonlocal scope.
- What the global scope is.
- How to modify behavior using the `global` statement.
- How to modify behavior using the `nonlocal` statement.

Knowing these concepts allows for a stronger mastery of Python when working with names in programs and taking into consideration what parts of the programs they can be accessed or modified.

Keep up the great work!

Review

We just witnessed that we can access names from the enclosing scope with nested functions, but we cannot modify them. Python does however provide a way for us to modify names in the enclosing scope, by using the `nonlocal` statement.

Given the following enclosing and nested function, there is a variable defined in the enclosing scope, which is not modifiable from within the nested function. 

```py
def enclosing_function():
  var = "value"

  def nested_function():
    var = "new_value"

  nested_function()

  print(var)

enclosing_function()
```

The output would be:
```
value
```

as the value of `var` was not modified by the nested function. After using the `nonlocal` statement, the variable is now modifiable from the local scope.
```py
def enclosing_function():
  var = "value"

  def nested_function():
    nonlocal var
    var = "new_value"

  nested_function()
  print(var)

enclosing_function()
```

The output would now be:
```
new_value
```

Let's practice modifying variables in a nested context in our painting application for Jiho!

Modifying Scope Behavior: nonlocal Statement

Sometimes, we want to modify a global name from within a local scope. How do we go about doing this? 
```py
global_var = 10

def some_function():
  global_var = 20

some_function()

print(global_var)
```

The output would be:
```
10
```
In the above example, the value of `global_var` remains `10` because `global_var = 20` is in a local scope.

Similar to the `nonlocal` statement, Python provides the `global` statement to allow the modification of global names from a local scope. 

```py
global_var = 10

def some_function():
  global global_var
  global_var = 20

some_function()

print(global_var)
```

The output would now be:
```
20
```

In addition, the `global` statement can be used even if the name has not been defined in the global namespace. Using the `global` statement would create the new variable in the global namespace.

```py
def some_function():
  global x
  x = 30

some_function()
print(x)
```

This would output:
```
30
```

In summary, the `global` keyword is used within a local scope to associate a variable name with a name in the global namespace. This association is only valid within the local scope when `global` is used.