Python name binding

Python’s name binding

In Python, objects are associated and referenced through names. Python introduces names through name binding operations.

The so-called code block in Python is a program that serves as an execution unit. For example: modules, functions, class definitions. Commands entered in an interactive environment are also a type of code block. A Python script file is also a block of code. Also, when we use the -c option on the command line, the command specified is also a code block. The string parameters passed to the built-in functions eval() and exec() are also a type of code block.

Code blocks are executed in the form of execution frames. An execution frame contains some management information and can be used for debugging. The execution frame also specifies where and how to execute the next code after the current block of code is executed.

Scope in Python defines the visibility of a name within a block of code. If a local variable is defined in a code block, the scope of the local variable is the code block in which it is located. If this definition occurs within a function body, the scope of this variable extends to any code block contained in this function. However, if within a code block contained in this function, the same name is bound to a different object, then outside names will not be expanded into this code block.

def out_func():
    #a的作用域在out_func这个函数中
    a = 0
    b = 0
    def in_func():
    #a的作用域从out_func扩展到了in_func中，因为in_func这个代码块包含在out_func中
    print(a)
    #out_func函数中的b不能扩展到in_func中，因为在in_func中，b重新绑定到了不同的对象上，所以在out_func中的b的作用域不能扩展到in_func中。
    b = 1

In Python, names defined in class code blocks can only be visible in the class, and the scope of names in the class cannot be extended to methods in the class. If generator expressions and list expansions appear in a class definition, names in the class cannot be expanded into these expressions, because list expansions and generator expressions are implemented using function scope.

class C:
    a = 0
    # 在列表表达式中，a会因为未定义而抛出NameError异常
    b = list(a + i for i in range(10))
    def method(self):
        #由于定义在类中的名字不能扩展到方法中，所以下面的语句是错误的，会抛出a未定义的NameError异常
        print(a)

When a name is used in a code block, the nearest enclosing scope is parsed to find the name. The set of all these scopes visible in the current code block is called the environment of the current code block.

The relationship between name binding and scope

If a name is bound to a code block, unless the name is declared as nonlocal (the function of the nonlocal declaration is to make the variable in the outer scope, before the global scope parsed), otherwise this name is a local variable of this code block. If a name is bound to the module level, the scope of the name is global and the variable is a global variable (variables in the module are local variables for the module, and for code blocks in the module, then is a global variable). If a name is used in a code block but is not defined within the code block, the variable is a free variable.

Exceptions related to name binding

If the name is not found during name search, a NameError exception will be thrown. If the name refers to a local variable, but the name has not been bound to this Local variables, an UnboundLocalError exception will be thrown (UnboundLocalError is a subclass of NameError).

Situations in which name binding behavior occurs

The main behaviors in which name binding occurs are:

Usually when passing parameters to a function, the parameter name will be bound to the passed object

Using the import statement to import When, the from...import * statement will bind all the names that can be imported in the imported module

When the class is defined

When the function is defined

When the assignment operation is performed

In the for statement of the for loop

After as in the with statement

After as in the expect statement

Pitfall of name binding in Python

In Python, some rules of name binding will lead to When using names, incomprehensible errors occur, especially for users with experience in C, C++ and Java.

In Python, no matter where the name binding operation occurs anywhere in the current block, the reference to the name in this code block will use the object bound in the current block. Then, the problem arises, if we reference the name before the name binding operation occurs, an error will occur and an UnboundLocalError exception will be thrown.

>>> a = 10
>>> def function():
print(a)
a = 20# a的绑定操作发生在print之前
>>> function()
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    function()
  File "<pyshell#4>", line 2, in function
    print(a)
UnboundLocalError: local variable &#39;a&#39; referenced before assignment

In Python, local variables in a code block can obtain the bound name by scanning the entire code block, so in the above code, the name a is passed to the code block when printing is executed. The scan has been found, but the binding operation for name a has not yet occurred, so an error occurred.

In the above code, if we need a global variable a defined outside, we can use the global statement to declare it.

>>> a = 10
>>> def function():
global a
print(a)
a = 20#这里并不引入新的名字，而是将全局变量a绑定到20上
>>> function()
10
>>> a
20

global statement is to make subsequent references to the object declared through this statement use the name in the top-level namespace. The top-level namespace includes the global namespace and built-in namespace. The global namespace will be searched first. If not found, the built-in namespace will be searched. The global statement must appear before the name is used.

If a free variable in the outer scope contains a global declaration, the free variable is considered global.

Built-in namespace

When searching for the built-in namespace, the __builtins__ name in the global namespace of the current code block will be accessed. This name refers to a name dictionary or a module. In the __main__ module, __builtins__ refers to the built-in module builtins. However, if it is in other modules, __builtins__ refers to the name dictionary of the builtins module.

Note:

In the implementation of CPython, the variable __builtins__ cannot be modified manually. If you need to overwrite the name in this built-in name space, you need to import the builtins module and then modify the corresponding attributes in this module.