Python Namespace and Scope: In Python, a namespace is a mapping from names to objects. It provides a way to organize and manage names in a program, ensuring that names are unique and do not conflict with each other. Namespaces play a crucial role in determining the scope of variables and other objects.
Scope, on the other hand, defines the visibility and accessibility of names within a program. It determines where a name can be accessed and which part of the program can reference it. Python has several types of scopes, including global scope, local scope, and built-in scope.
Let’s explore the concepts of namespace and scope with an example:
# Global scope global_var = 10 def my_function(): # Local scope local_var = 20 print(local_var) # Output: 20 print(global_var) # Output: 10 my_function() print(global_var) # Output: 10 print(local_var) # NameError: name 'local_var' is not defined
In this example, we have a global variable
global_var defined outside any function. It is accessible from anywhere in the program, including inside functions. Within the
my_function() function, we define a local variable
local_var, which is only accessible within the function’s local scope. When we print
local_var within the function, it successfully displays the value of
20. However, when we try to access
local_var outside the function, we get a
NameError because it is not defined in the global scope.
Each function in Python has its own local scope, which is created when the function is called and destroyed when the function finishes executing. Names defined within a function are part of its local namespace and are not accessible outside the function. Similarly, variables defined in the global scope are part of the global namespace and can be accessed throughout the program.
Python also has a built-in namespace that contains pre-defined names like built-in functions and modules, such as
math. These names are always accessible without explicitly importing or defining them.
Understanding namespaces and scopes is essential for managing variable names and avoiding naming conflicts. By organizing names into separate namespaces with different scopes, we can maintain clarity and control over our program’s variables and objects.