Understanding Namespaces in Python

Vipul Malhotra
2w
161
0
4

Article

Namespaces are a fundamental concept in Python that helps organize and manage the scope of variables, functions, and objects. They ensure that names (identifiers) in a program do not conflict with each other. In this article, we will talk about global() and local() functions and the LEGB rule.

What is a Namespace?

A namespace in Python is a mapping between names (identifiers) and objects. It is a way to ensure that all the names in a program are unique and can be used without conflict. Namespaces are implemented as dictionaries in Python, where the keys are the names and the values are the objects they reference.

There are several types of namespaces in Python.

Built-in Namespace: Contains the built-in functions and types (e.g., print(), len(), int, str). This namespace is created when the Python interpreter starts and is deleted when the Python interpreter ends.
Global Namespace: Contains the names defined at the top level of a module or script. This namespace is created when the module is imported or the script is executed and lasts until the module is unloaded or the script finishes.
Local Namespace: Contains the names defined within a function or method. This namespace is created when the function is called and is deleted when the function returns or raises an exception.
Enclosing Namespace: Contains the names defined in the enclosing scope of a nested function. This namespace is created when the outer function is called and is deleted when the outer function returns. This is created when there is a scenario of nested functions.

The LEGB Rule

The LEGB rule defines the order in which Python looks up names (variables, functions, etc.) in a program. LEGB stands for,

Local (L): The innermost scope, which includes local variables defined within the current function.
Enclosing (E): The scope of any enclosing functions, if the current function is nested.
Global (G): The scope of the module or script in which the current function is defined.
Built-in (B): The outermost scope, which contains built-in names like print, len, etc.

Python searches for a name in the order of Local → Enclosing → Global → Built-in. If the name is not found in any of these scopes, a NameError is raised.

Example of LEGB Rule

x = 10  # Global scope


def outer():
    x = 20  # Enclosing scope

    def inner():
        x = 30  # Local scope
        print("Local x:", x)  # Output: 30

    inner()
    print("Enclosing x:", x)  # Output: 20


outer()
print("Global x:", x)  # Output: 10

In this example,

The inner function first looks for x in its local scope and finds x = 30.
The outer function looks for x in its enclosing scope and finds x = 20.
The global scope contains x = 10.

The globals() Function

The globals() function returns a dictionary representing the current global namespace. This dictionary contains all the global variables, functions, and classes defined in the current module or script.

Example of globals()

# Global variable
x = 10

# Global function
def foo():
    print("Inside foo")

# Accessing the global namespace
global_namespace = globals()

# Printing the global namespace
print(global_namespace)

# Output:
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1010c0d60>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/vipulmalhotra/Documents/source/repo/python-concepts/NamespaceLookups/Namespace.py', '__cached__': None, 'x': 10, 'foo': <function foo at 0x101088180>, 'global_namespace': {...}}

# Accessing global variables and functions using the global namespace
print(global_namespace['x'])  # Output: 10
global_namespace['foo']()     # Output: Inside foo

global_namespace['x'] = 33
print(global_namespace['x'])  # Output: 33

In this example, globals() returns a dictionary containing the global variable x and the function foo. We can access these objects using the dictionary keys.

We can also change the value of a global variable directly in the globals() and it will be reflected (refer to code snippet above)

The locals() Function

The locals() function returns a dictionary representing the current local namespace. This dictionary contains all the local variables, functions, and classes defined within the current scope (e.g., inside a function or method).

Example of locals()

def bar():
    # Local variable
    y = 20

    # Accessing the local namespace
    local_namespace = locals()

    # Printing the local namespace
    print(local_namespace)  # Output: {'y': 20}

    # Accessing local variables using the local namespace
    print(local_namespace['y'])  # Output: 20


# Calling the function
bar()

In this example, locals() returns a dictionary containing the local variable y inside the function bar. We can access this variable using the dictionary key.

Please note that locals() is immutable, more details on differences are below.

Differences Between globals() and locals()

Scope: globals() returns the global namespace, which includes all the names defined at the top level of a module or script. locals() returns the local namespace, which includes all the names defined within the current scope (e.g., inside a function or method).
Mutability: The dictionary returned by globals() is mutable, meaning you can modify the global namespace by adding, updating, or deleting entries in the dictionary. The dictionary returned by locals() is not mutable. Modifying the locals() dictionary will not affect the local namespace.

Practical Use of LEGB

The LEGB rule is particularly useful when working with nested functions or when you need to access variables from different scopes.

Example. Accessing Enclosing Scope

def outer():
    message = "Hello from outer"
    
    def inner():
        print(message)  # Accesses the enclosing scope
    
    inner()

outer()  # Output: Hello from outer

Here, the inner function accesses the message variable from the enclosing scope of the outer function.

Conclusion

Namespaces and the LEGB rule are essential concepts in Python that help manage the scope of variables, functions, and objects. The globals() and locals() functions provide a way to inspect and manipulate the global and local namespaces, respectively.

By using namespaces effectively and following the LEGB rule, we can avoid naming conflicts.