ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


In this lesson, you'll learn about Python namespaces - a way for Python to manage all the objects that exist in our programs! 

Namespaces

![Enclosing Namespace Python](https://static-assets.codecademy.com/Courses/Intermediate-Python/Types-of-Namespaces_3_final.gif)

There is just one more namespace we need to be aware of in our Python programs. This particular namespace is a special type of local namespace called the _enclosing namespace_. 

Enclosing namespaces are created specifically when we work with nested functions and just like with the local namespace, will only exist until the function is done executing. Let’s take a look at an example:
```py
global_variable = 'global'

def outer_function():
  outer_value = "outer"

  def inner_function():
    inner_value = "inner"

 inner_function()

outer_function()
```

In this program, the following occurs: 
- We define a function called `outer_function()` and nest another function inside it called `inner_function()`. To generate a namespace, functions must be executed, so we are calling both of them. 
- Here, The `outer_function()` serves the role of an _enclosing function_ while `inner_function` is an _enclosed function_. By creating this structure, we generate an enclosing namespace - a namespace created by an enclosing function and any number of enclosed functions inside it. 

While Python doesn’t give us any particular function like `enclosing()` to visualize the namespace, we can use `locals()` to see when enclosed namespaces are generated. Let's take a look by modifying our script: 
```py
global_variable = 'global'

def outer_function():
  outer_value = "outer"

  def inner_function():
    inner_value = "inner"
  inner_function()
  # Added locals output
  print(locals())

outer_function()
```

Would output: 
```bash
{'outer_value': 'outer', 'inner_function': <function outer_function.<locals>.inner_function at 0x7f46b56bc820>}
```

Notice the `'inner_function': <function outer_function.<locals>.inner_function` shows that our local namespace inside of `outer_function()` encloses the local namespace of `inner_function()`. 

Let's practice accessing the enclosing namespace in a similar example! 

Enclosing Namespace

![Python Built-in Namespace](https://static-assets.codecademy.com/Courses/Intermediate-Python/Types-of-Namespaces_1_final.gif)

One of the four main types of namespaces that exist in Python is the _built-in namespace_. 

Ever wonder why functions like `print()` and `str()` are available to us in all our programs? Well, Python knows these function ***names*** because they exist in the highest level of namespaces and thus can be called in any program we write.

Whenever we run a Python application, we are provided a built-in namespace that is created when the interpreter is started and has a lifetime until the interpreter terminates (usually when our program is finished running). Since Python provides the namespace, these objects are accessible without the need to import a separate module.

Let's take a look together at the standard built-in namespace! In order to see it, we can use the following statement: 

```python
print(dir(__builtins__))
```

This allows us to access the `builtins` module that Python provides for us. Our output would give us: 

```bash
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
```

Wow! That's a bit overwhelming. Let's note a few interesting facts about the objects hosted built-in namespace: 

- It contains many of the built-in functions we are able to use in our Python programs such as `str()`, `zip()`, `slice()`, `sorted()`, and many more. 
- It also hosts many of the exceptions that we may encounter in our programs such as `'ArithmeticError'`, `'IndexError'`, `'KeyError'`, and many more. 
- There are even constants like `True` and `False`! 

In total there are 152 names that include exceptions, functions, types, special attributes, and other Python built-in objects.

Built-in Namespace

![Python Local Namespace](https://static-assets.codecademy.com/Courses/Intermediate-Python/Types-of-Namespaces_3_final.gif)

Now that we have examined the built-in and global namespaces, let's dive into the deepest level of namespaces - the _local namespace_. To do so, let's start by examining this program: 
```py
global_variable = 'global'

def add(num1, num2):
  nested_value = 'Inside Function'   
  print(num1 + num2)

add(5, 10) 
```

Here, we have defined two values: a `global_variable` and a `add()` function. In Python, whenever the interpreter executes a function, it will generate a local namespace for that specific function. This namespace only exists inside of the function and remains in existence until the function terminates.

Similar to how we can see the global namespace using a built-in function called `globals()`, Python provides a function called `locals()` to see any generated local namespace. Let's refactor our program just slightly and see what exists inside of a local namespace:
```py
global_variable = 'global'

def add(num1, num2):
  nested_value = 'Inside Function'   
  print(num1 + num2)
  print(locals())

add(5, 10) 
```

Would output: 
```bash
15
{'num1': 5, 'num2': 10, 'nested_value': 'Inside Function'}
```

Notice the following: 
- We called `locals()` inside the `add()` function to get the local namespace generated when the function is executed. If we called ` locals()` outside of a function in our program, it behaves the same as `globals()`.

- The value printed from calling `locals()` represents the namespace that only exists inside of the function. Notice even the function parameters `num1` and `num2` exist alongside the variable name `nested_value`. The namespace does not include `global_variable` since it exists outside of the function (in the global namespace). 

Let's now practice examining the local namespace!

Local Namespace 

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

In this lesson, we've covered:
- Names as identifiers for objects in Python.
- What namespaces are.
- The built-in namespace and how to access it using `__builtins__`.
- The global namespace and how to access it using `globals()`.
- The local namespace and how to access it using `locals()`.
- The enclosing namespace - a special type of local namespace that occurs when working with nested functions.

Knowing these concepts allows for a stronger mastery of Python since names are the basis of how our programs store and retrieve information. Keep up the great work!

Review

![Python Global Namespace](https://static-assets.codecademy.com/Courses/Intermediate-Python/Types-of-Namespaces_2_final.gif)

The _global namespace_ exists one level below the built-in namespace. Generally, it includes all non-nested names in the module (file) we are choosing to run the Python interpreter on. The global namespace is created when we run our main program and has a lifetime until the interpreter terminates (usually when our program is finished running). For example, take this program: 

```py
#Imaginary File: main.py
import random

first_name = "Jaya"
last_name = "Bodegard" 

def print_variables():
  random_number = random.randint(0,9)
  print(first_name)
  print(last_name)
  print(random_number)
```
Our script consists of a few different variables, a function, and an imported module. Right off the bat, it might not be clear what exists in the global namespace. Thankfully, in order to see what objects exist in the global namespace, Python provides the `globals()` built-in function. 

Funnily enough, the `globals()` function actually comes from the built-in namespace (and is thus called a built-in function), and we can access it anywhere in our program (or any program)! Let's see what it would return if we print the output inside of the program above: 

```python
# ...code from above (omitted for brevity)
print(globals())
```

Would output: 
```bash
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f224a7ae4c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'main.py', '__cached__': None, 'random': <module 'random' from '/usr/lib/python3.8/random.py'>, 'first_name': 'Jaya', 'last_name': 'Bodegard', 'print_variables': <function print_variables at 0x7f224a76a1f0>}
```

Again, we have a lot of nonsense-looking text. Don't worry there are only two things we should focus on: 

1. The global namespace contains all of the non-nested objects of our program. This includes the variables `first_name` and `last_name` as well as the function `print_variables`. However, the `random_number` variable is not included in the namespace because it is nested inside of our function. Don't worry we will learn about the namespace that `random_number` exists inside in the next exercise. 

2. Anytime we use the `import` statement to bring in a new module into our program, instead of adding every name from that module (such as all the names in the `random` module) to our current global namespace, Python will create a new namespace for it. This means there might be potentially multiple global namespaces in a single program. This will be masked away from us in the format seen with the `random` module (`<module 'random' from '/usr/lib/python3.8/random.py'>`). 

Don't fret over the rest of the namespace we didn't touch on, it is a lot of behind-the-scenes built-in python objects that are usually present in all scripts. For now, we will focus on the parts we can manipulate. 

Let's practice using the `globals()` function to check out the global namespace in a program!

Global Namespace

In Python, a _name_ (sometimes also called a _symbolic name_) is an identifier for an object. In the programs we have written so far, we have been using the concept of naming all along! Let's take a look at an example:
```py
color = "cyan"
```
Here, we assign `color` as the ***name*** of the string `"cyan"`. 

Python uses the system of names so that it can differentiate between each distinct object (such as a string or a function) that we define. In most programs, Python has to keep track of the hundreds and sometimes even thousands of names. So, how exactly does Python store all of this information? Well, it creates what is called a _namespace_. 

A namespace is a collection of names and the objects that they reference. Python will host a dictionary where the keys are the names that have been defined and the mapped values are the objects that they reference.

In the example above, the namespace Python creates would look something like this:
```
{'color': 'cyan'}
```
So, in this case, if we tried to print the variable `color`: 

```py
print(color)
```
Python would search the namespace defined above for a key named `color` and provide the value to be run in our program. Thus we would see the output of `'cyan'`.

In the next exercises we will explore the four distinct types of namespaces that Python generates: 
1. Built-In
2. Global
3. Local
4. Enclosing

We'll learn all about the different types and how they are generated and managed. For now, let's examine a visual representation of how namespaces get generated.