Detailed explanation of namespaces in Python

As a dynamic language, Python maintains a named environment of constants, variables, functions, etc. when the code is executed. This environment is the namespace, which can also be called a namespace. This article will introduce namespaces in Python in detail.

1. Namespace Overview
   The namespace in Python is a dictionary that stores the correspondence between names and objects, where the name refers to the identifier (identifier), and the object refers to all objects. Everything in Python is an object, including integers, floating point numbers, strings, functions, classes, etc.
2. Namespace classification
   Namespaces in Python can be divided into three types:

(1) Built-in Namespace (Built-in Namespace)
Built-in naming The space is a namespace loaded when the Python interpreter starts. The built-in namespace contains some functions and variables by default, such as print(), type(), str(), etc., which developers can use directly. Built-in namespaces are also accessible through the builtins module.

(2) Global Namespace(Global Namespace)
Global namespace refers to variables, functions, etc. defined in the module, rather than defined in the function or class. Global variables defined in one module can also be accessed in other modules. A module has only one global namespace, and all functions in the module can access this namespace.

(3) Local Namespace (Local Namespace)
The local namespace is a namespace created when a function is called and is used to store local variables, parameters, temporary variables, etc. of the function. When the function ends calling, the local namespace is also destroyed.

3. Namespace search rules
   When using a variable, Python will first search for the corresponding variable in the local namespace. If not found, it will search in the global namespace, and finally Look in the built-in namespace. In other words, Python searches for variables in the order of local, global, and built-in. This order of searching for variables is called the LEGB rule.
4. The scope of the namespace
   In Python, each function, module, and class has its own namespace. When a name is bound to an object, it only has meaning within that namespace. If the name is bound to a local namespace, it has meaning only within the function; if the name is bound to the global namespace, it has meaning within the module; if the name is bound to the built-in namespace space, it makes sense throughout the Python interpreter.
5. Obtain the namespace through the globals() and locals() functions
   You can use the globals() and locals() functions in Python to obtain the corresponding global namespace and local namespace. The globals() function returns the dictionary of the global namespace, and the locals() function returns the dictionary of the local namespace.
6. Notes on namespaces
   (1) The names in the namespace must be legal identifiers.
   (2) Functions and classes create a new namespace.
   (3) Variable names can be re-bound to other objects in the namespace.
   (4) Use the global statement to allow variables inside the function to refer to global variables.
   (5) Use the nonlocal statement to allow variables inside the function to refer to local variables of the outer function.
   (6) The namespace search in Python is based on LEGB rules.
7. Conclusion
   This article introduces namespaces in Python in detail, including namespace overview, namespace classification, namespace search rules, namespace scope, and acquisition through globals() and locals() functions Namespaces, etc. For Python beginners, understanding namespaces is an important step in learning the Python language.

The above is the detailed content of Detailed explanation of namespaces in Python. For more information, please follow other related articles on the PHP Chinese website!