Python Namespace and scope – Get unique names for each object

In your school, college or office, confusion can arise because of people having the same names. This confusion is usually resolved by providing a unique identity like using first name and last name. The same problem can arise in programming also.

If you write a few lines of code then it is not a problem to assign unique names to every variable. But when you load external modules and write thousands of lines of code then it is not possible to use unique and meaningful names for every object or variable.

This is why namespaces are important and this article will be covering everything about Python namespace and scope.

What is Python Namespace?

A namespace is a collection of names. Python implements namespaces as dictionaries. Imagine it as a name-to-object mapping where names are the keys and objects are the values.

A namespace allows us to have unique names for each object. If you don’t know, this is just a quick reminder to tell you that strings, lists, functions, etc. everything in Python is an object.

In simple words, we can say that the role of a namespace is like a surname.

There can be multiple “Tom” in the same class but there will be a single “Tom Hanks” (let’s just assume this) in the class and with surname, you can identify between multiple “Tom”.

The Python interpreter does the same thing to understand what exact method or variable one is pointing to in the code. The namespace word itself can be broken down as name (which is a unique identifier) + space (which means relating to scope).

The name can be anything from method name to variable name and space depends upon the location from where we are trying to access a variable or a method.

Types of Namespaces in Python

Namespaces are of basically three types:

1. Built-in Namespace

This namespace includes functions and exception names that are built-in in the Python. Examples include built-in functions like print(), len(), and built-in exceptions like ValueError and TypeError. The built-in namespace is always available and can be accessed from anywhere in the code, providing a foundation of readily available utilities.

2. Global Namespace

This namespace includes names from the modules that are imported in the project. It is created when we include the module and it lasts until the script ends. Variables and functions defined at the top level of a script or module are part of the global namespace. This allows them to be accessed from any part of the code after their declaration, as long as the script or module is still running.

3. Local Namespace

The local names inside a function come under a local namespace. This namespace is created when the function is called and its scope ends when the function returns a value or exits. Variables defined within a function are local to that function and cannot be accessed from outside. This encapsulation helps prevent conflicts between variables in different parts of the program and allows for better modularity and readability.

Python Scope

With namespaces, we can uniquely identify all the names inside a program. However, it doesn’t mean that we can use the variable names anywhere we want. It also has some scope that indicates the part of the program where we can access them.

We can directly access the variables without any prefix when they are in the namespace. The lifetime of a namespace is dependent on the scope of objects. When the scope of an object comes to end, the lifetime of the namespace also comes to an end.

So, we cannot access the inner namespace scope’s objects from an outer namespace.

Python has the following scopes –

When a name is referenced in Python, the interpreter searches the name in the namespace starting from the smallest scope in the diagram and gradually moves towards the outermost scope.

• The local scope, which is the innermost scope contains a list of local names that are only available in the function.
• Enclosing scopes are seen in nested functions where names are searched in the nearest outside function.
• The global scope is the module-level scope. When we import modules, they get added to the global scope.
• The outermost scope is of the built-in names scope. The interpreter searches names in this scope at last.

Example of Python Namespaces and Scope

Now, we will see some examples of namespaces and scope –

Example 1

#var1 is in the global namespace
var1 = 5
def function():

    # var2 is in the local namespace
    var2 = 6
    def inner_function():

        # var3 is in the nested local
        # namespace
        var3 = 7

In this example, the var1 is declared in the global namespace because it is not enclosed inside any function. So it is accessible everywhere in the script.

var2 is inside the function(). So, it can be accessed only inside the function() and outside the function, it no longer exists.

var3 also has a local scope, the function is nested and we can use var3 only inside inner_function().

Example 2

var = "10"
def example():
  var = "30"
  def method():
    global var
    var = "40"
    def function():
      global var
      var = "50"
      print("Function Scope: " + var)
    function()
    print("Method Scope: " + var)
  method()
  print("Example Scope: " + var)
example()
print("Module Scope: " + var)

Output:

Let’s break down how we got the following output –

In the global scope first, we declared the variable ‘var’ and initialized it with value = 10.

In the example() function, we declare a local variable ‘var’ =30.

Since they are declared in different namespaces, we can have variables with the same names in different scopes.

The global keyword is used to indicate that we are referencing the global variable in this scope that is why in function() the value now holds 50.

Same as method() function and the example() function is holding the local variable whose value is 30 and in the end, the last value of the global variable was 50.

Summary

In this python namespace and scope article of TechVidvan, we studied about the namespaces and scope in Python. They are necessary to solve the problem of conflicting names while naming objects.

We saw the different types of namespaces (built-in, global and local) and scopes. Further on, we saw easy examples of namespaces and scope.