Python进阶：深入解析命名空间与作用域机制

前言

除非另有说明，本文内容均基于Python3环境。

命名空间与作用域紧密关联着名字的绑定过程，建议结合介绍Python名字、对象及其绑定的相关文章一同阅读以加深理解。

1. 命名空间

1.1 什么是命名空间

Namespace（命名空间），亦称名字空间，本质上是名字到对象的映射关系。在Python中，大部分命名空间由字典实现，但本文不探讨其底层实现细节。命名空间的核心作用在于避免名字冲突：

def fun1():
  i = 1

def fun2():
  i = 2

即使两个函数中存在同名的变量i，它们也互不影响，因为这两个名字分别属于不同的命名空间。

1.2 命名空间的种类

常见的命名空间包括以下几种：

内置（built-in）名字集合，包含如abs()等内置函数及内置异常名等。通常将包含这些名字的命名空间称为内置命名空间。

模块全局名字集合，指直接定义在模块层面的名字，例如类、函数、导入的其他模块等。通常称为全局命名空间。

函数调用过程中的名字集合，包括函数参数及函数体内定义的名字。这些名字在函数调用时被“激活”，构成局部命名空间。

对象的属性集合也构成一个命名空间。但由于通常通过objname.attrname的方式间接访问属性，而非直接访问，因此一般不将其纳入命名空间的讨论范畴。

类定义的命名空间。当解释器执行到class ClassName:语句时，会新建一个命名空间（详见官方对类定义的说明）。

1.3 命名空间的生命周期

不同类型的命名空间拥有不同的生命周期：

内置命名空间在Python解释器启动时创建，在解释器退出时销毁；

全局命名空间在模块定义被解释器读入时创建，在解释器退出时销毁；

局部命名空间需区分函数与类定义。函数的局部命名空间在函数调用时创建，在函数返回或发生未捕获异常时销毁；类定义的命名空间在解释器读取到类定义时创建，在类定义结束后销毁（注：虽然类定义结束后该命名空间看似销毁，但类对象实际上是该内容的一个包装，详见官方对类定义的说明）。

2. 作用域

2.1 什么是作用域

作用域是Python中的一块文本区域，在此区域内，命名空间可以被“直接访问”。这里的直接访问指的是试图在命名空间中查找名字的绝对引用（即非限定引用）。此处有必要解释直接引用与间接引用的区别：

直接引用：直接使用名字访问，如name。这种方式会在命名空间中搜索名字name。

间接引用：使用形如objname.attrname的方式，即属性引用。这种方式不会在命名空间中搜索名字attrname，而是先搜索名字objname，再访问其属性。

2.2 与命名空间的关系

既然命名空间持有名字，而作用域是代码文本区域（即代码块），需要引用名字（访问变量），那么作用域与命名空间之间必然存在联系。

顾名思义，名字作用域是指名字可以影响到的代码文本区域，而命名空间的作用域则是指该命名空间可以影响到的代码文本区域。因此，可能存在一个代码文本区域，受到多个命名空间的影响。 作用域仅是文本区域，其定义是静态的；而命名空间是动态的，只有随着解释器的执行，命名空间才会产生。这种在静态作用域中访问动态命名空间中的名字，导致了作用域使用的动态性。

因此，可以这样理解：

静态的作用域，是一个或多个命名空间按照一定规则叠加影响代码区域；运行时动态的作用域，则是按照特定层次组合起来的命名空间。

在某种程度上，可以认为动态的作用域等同于命名空间。在后续表述中，我将把动态的作用域与其对应的命名空间视为等同。

2.3 名字搜索规则

当程序中引用了一个名字，Python是如何搜索到这个名字的呢？

在程序运行时，至少存在三个可以被直接访问的作用域，它们对应着命名空间：

Local（局部） 首先搜索包含局部名字的最内层（innermost）作用域，例如函数、方法或类内部的局部作用域；

Enclosing（嵌套） 根据嵌套层次从内到外搜索，包含非局部（nonlocal）且非全局（nonglobal）名字的任意封闭函数的作用域。例如在两个嵌套函数中，内层函数的作用域是局部作用域，而外层函数的作用域则构成内层函数的Enclosing作用域；

Global（全局） 倒数第二次被搜索，包含当前模块全局名字的作用域；

Built-in（内置） 最后被搜索，包含内建名字的最外层作用域。

程序运行时，L、G、B三个作用域是一定存在的，而E作用域不一定存在；若程序结构如下：

i = 1
print(i)

那么局部作用域在哪里呢？根据(Python Scopes And Namespaces)的说明：

Usually, the local scope references the local names of the (textually) current function. Outside functions, the local scope references the same namespace as the global scope: the module's namespace. Class definitions place yet another namespace in the local scope.

一般地，局部作用域引用函数中定义的名字。在函数之外，局部作用域和全局作用域引用同一个命名空间：模块的命名空间。然而，类的局部作用域引用了类定义中新建的命名空间。

Python按照L-E-G-B的顺序依次在四个作用域中搜索名字。如果未搜索到，Python将抛出NameError异常。

2.4 何时引入作用域

我们知道：

在Python中，一个名字只有在定义之后，才能被引用。

print(i)

直接引用未定义的名字i，按照搜索规则，在L、G、B三个作用域（其中L和B指向相同命名空间）中均未搜索到名字i，从而抛出NameError异常：

Traceback (most recent call last):
 File "scope_test.py", line 15, in <module>
  print(i)
NameError: name 'i' is not defined

那么对于这段代码呢？

def try_to_define_name():
  '''函数中定义了名字i，并绑定了一个整数对象1'''
  i = 1

try_to_define_name()
print(i) #引用名字i之前，调用了函数

在引用名字i之前，明明调用了函数并定义了名字i，却依然找不到这个名字：

Traceback (most recent call last):
 File "scope_test.py", line 20, in <module>
  print(i) #引用名字i之前，调用了函数
NameError: name 'i' is not defined

虽然定义了名字i，但它是定义在函数的局部作用域对应的局部命名空间中。按照LEGB搜索规则，在全局作用域中自然无法访问局部作用域；此外，函数调用结束后，该命名空间已被销毁。

引用名字总是与作用域相关的，因此：

在Python中，一个名字只有在定义之后，才能在合适的作用域内被引用。

因此，在定义名字时，必须注意名字定义的作用域，以免定义后需要访问时却找不到。所以，了解Python在何时会引入新的作用域至关重要。一般来说，B和G两个作用域的引入无法通过代码操作，能够通过语句引入的作用域只有E和L。Python中引入新作用域的语句非常有限，总的来说只有两类：

函数定义引入local作用域或者Enclosing作用域；本质上，lambda和生成器表达式也是函数，会引入新作用域。

类定义引入local作用域；

列表推导式引入local作用域，传说在Python2中列表推导式不引入新的作用域。

几个会让有其他高级语言经验的开发者困惑的地方：

if语句：

if True:
  i = 1
print(i) # output: 1，而不是NameError

if语句并不会引入新的作用域，所以名字绑定语句i = 1与print(i)是在同一个作用域中。

for语句：

for i in range(6):
  pass
print(i) #output: 5，而不是NameError

for语句同样不会引入新的作用域，所以名字i的绑定和重绑定与print(i)在同一个作用域。这一点Python就比较“坑”了，因此写代码时切忌for循环名字要与其他名字重名。

import语句：

def import_sys():
  '''import sys module'''
  import sys

import_sys()
print(sys.path) # NameError: name 'sys' is not defined

这算非正常程序员的写法了。在函数import_sys中，import语句将名字sys和对应模块绑定，那么sys这个名字还是定义在局部作用域，跟上面的例子没有区别。要时刻切记Python的名字、对象机制与其他编程语言不同，但是：

打破第一编程语言认知的第二门编程语言，才是值得去学的好语言。

3. 作用域应用

3.1 自由变量可读不可写

我不太想用“变量”这个词来形容名字，奈何“变量”已是家喻户晓。Python中的自由变量：

If a variable is used in a code block but not defined there, it is a free variable.

如果引用发生的代码块不是其定义的地方，它就是一个自由变量。专业一点来说：

引用名字的作用域中没有这个名字，那这个名字就是自由名字。

注：“自由名字”只是作者YY的，并没得到广泛认可。

我们已经了解了作用域有LEGB的层次，并按顺序搜索名字。按照搜索顺序，当低层作用域不存在待搜索名字时，引用高层作用域存在的名字，也就是自由名字：

[示例1]

def low_scope():
  print(s)

s = 'upper scope'
low_scope()

很清楚，这段代码的输出是upper scope。

[示例2]

def low_scope():
  s = 'lower scope'

s = 'upper scope'
low_scope()
print(s)

很遗憾，最后的打印语句没有按照期待打印出lower scope，而是打印了upper scope。

A special quirk of Python is that – if no global statement is in effect – assignments to names always go into the innermost scope.

Python的一个怪癖是，如果没有使用global语句，对名字的赋值语句通常会影响最内层作用域。 即赋值语句影响局部作用域，赋值语句带来的影响是绑定或重绑定。但是在当前局部作用域的命名空间中，并没有s这个名字，因此赋值语句在局部作用域中定义了同名名字s，这与外层作用域中的s并不冲突，因为它们分属不同命名空间。 这样，全局作用域的s没有被重绑定，结果就很好解释了。

当涉及可变对象时，情况又有所不同了：

[示例3]

def low_scope():
  l[0] = 2

l = [1, 2]
low_scope()
print(l) # [2, 2]

很遗憾，最后的打印语句没有按照期待输出[1, 2]，而是输出了[2, 2]。 上一个例子的经验并不能运用在此，因为list作为一个可变对象，l[0] = 2并不是对名字l的重绑定，而是对l的第一个元素的重绑定，所以没有新的名字被定义。因此在函数中成功更新了全局作用域中l所引用对象的值。

注意，下面的示例跟上面的是不一样的：

[示例4]

def low_scope():
  l = [2, 2]

l = [1, 2]
low_scope()
print(l) # [1, 2]

我们可以用本节中示例1的方法解释它。

综上，可以认为：

自由变量可读不可写。

3.2 global和nonlocal

总是存在打破规则的需求：

在低层作用域中需要重绑定高层作用域名字，即通过自由名字进行重绑定。

于是global语句和nonlocal语句应运而生。

global_stmt ::= "global" identifier ("," identifier)*
The global statement is a declaration which holds for the entire current code block. It means that the listed identifiers are to be interpreted as globals. It would be impossible to assign to a global variable without global, although free variables may refer to globals without being declared global.

global语句是适用于当前代码块的声明语句。列出的标识符被解释为全局名字。虽然自由名字可以不被声明为global就能引用全局名字，但是不使用global关键字绑定全局名字是不可能的。

nonlocal_stmt ::= "nonlocal" identifier ("," identifier)*
The nonlocal statement causes the listed identifiers to refer to previously bound variables in the nearest enclosing scope excluding globals. This is important because the default behavior for binding is to search the local namespace first. The statement allows encapsulated code to rebind variables outside of the local scope besides the global (module) scope.

nonlocal语句使得列出的名字指向最近封闭函数中绑定的名字，而不是全局名字。默认的绑定行为会首先搜索局部作用域。nonlocal语句使得在内层函数中重绑定外层函数作用域中的名字成为可能，即使同名的名字存在于全局作用域。

经典的官方示例：

def scope_test():
  
  def do_local():
    spam = 'local spam'

  def do_nonlocal():
    nonlocal spam # 当外层作用域不存在spam名字时，nonlocal不能像global那样自作主张定义一个
    spam = 'nonlocal spam' # 自由名字spam经nonlocal声明后，可以做重绑定操作了，可写的。

  def do_global():
    global spam # 即使全局作用域中没有名字spam的定义，这个语句也能在全局作用域定义名字spam
    spam = 'global spam' # 自有变量spam经global声明后，可以做重绑定操作了，可写的。

  spam = 'test spam'
  do_local()
  print("After local assignment:", spam) # After local assignment: test spam
  do_nonlocal()
  print("After nonlocal assignment:", spam) # After nonlocal assignment: nonlocal spam
  do_global()
  print("After global assignment:", spam) # After global assignment: nonlocal spam


scope_test()
print("In global scope:", spam) # In global scope: global spam

作者说不行nonlocal的邪：

def nest_outter():
  spam = 'outer'

  def nest_inner():
    nonlocal spam1
    spam1 = 'inner'

  nest_inner()
  print(spam)

nest_outter()

Output:

 File "scope_test.py", line 41
  nonlocal spam1
SyntaxError: no binding for nonlocal 'spam1' found

4. 一些坑

作者曾经自信满满认为透彻了解了Python的作用域，但一大堆坑踩得措手不及。

4.1 坑1 - UnboundLocalError

def test():
  print(i)
  i = 1

i = 2
test()

Output:

Traceback (most recent call last):
 File "scope_test.py", line 42, in <module>
  test()
 File "scope_test.py", line 38, in test
  print(i)
UnboundLocalError: local variable 'i' referenced before assignment

其实忽略掉全局作用域中i = 2这条语句，都可以理解。

Usually, the local scope references the local names of the (textually) current function.

Python对局部作用域情有独钟。解释器执行到print(i)时，发现i在局部作用域没有。解释器尝试继续执行后面定义了名字i，解释器就认为代码在定义之前使用了名字，所以抛出了这个异常。如果解释器解释完整个函数都没有找到名字i，那就会沿着搜索链LEGB往上找了，最后找不到抛出NameError异常。

4.2 坑2 - 类的局部作用域

class Test(object):

  i = 1

  def test_print(self):
    print(i)

t = Test()
i = 2
t.test_print()

我就问问大家，这个输出什么？ 当然会出乎意料输出2了，特别是有其他语言经验的人会更加困惑。

上文强调过： 函数命名空间的生命周期是什么？调用开始，返回或者异常结束，虽然示例中是调用的方法，但其本质是调用类的函数。 类命名空间的作用域是什么？类定义开始，类完成定义结束。

类定义开始时，创建新的属于类的命名空间，用作局部作用域。类定义完后，命名空间销毁，没有直接方法访问到类中的i了（除非通过间接访问的方式：Test.i）。

方法调用的本质是函数调用：

class Test(object):

  i = 1

  def test_print(self):
    print(i)

t = Test()
i = 2
# t.test_print()
Test.test_print(t) # 方法调用最后转换成函数调用的方式

函数调用开始，其作用域与全局作用域有了上下级关系（L和G），函数中i作为自由名字，最后输出2。 因此，不能被类中数据成员和函数成员的位置迷惑，始终切记，Python中两种访问引用的方式：

直接引用：试图直接写名字name引用名字，Python按照搜索LEGB作用域的方式搜索名字。

间接引用：使用objname.attrname的方式引用名字attrname，Python不搜索作用域，直接去对象里找属性。

4.3 坑3 - 列表推导式的局部作用域

一个正常列表推导式：

a = 1
b = [a + i for i in range(10)]
print(b) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

现在把列表推导式放到类中：

class Test(object):

  a = 1
  b = [a + i for i in range(10)]
  print(b)

  def test(self):
    pass

Output:

Traceback (most recent call last):
 File "scope_test.py", line 15, in <module>
  class Test(object):
 File "scope_test.py", line 18, in Test
  b = [a + i for i in range(10)]
 File "scope_test.py", line 18, in <listcomp>
  b = [a + i for i in range(10)]
NameError: name 'a' is not defined

输出反馈名字a未定义。

上文强调过，解释器读取类定义开始class ClassName后，创建命名空间用作局部作用域。 语句a = 1，在这个局部作用域中定义了名字i（注：原文此处可能有误，应为a，但根据上下文逻辑，此处指代类属性a）。 语句b = [a + i for i in range(10)]，列表推导式同样创建了一个局部作用域。这个作用域与类定义的局部作用域并没有上下级关系，所以，自然没有任何直接访问名字a的方法。

Python中只有四种作用域：LEGB，因为类定义的局部作用域与列表推导式的局部作用域不是嵌套函数关系，所以并不能构成Enclosing作用域关系。因此它们是两个独立的局部作用域，不能相互访问。

既然是两个独立局部作用域，那么上述例子就等同于：

def test1():
  i = 1

def test2():
  print(i)

test1()
test2()

期待在test2中访问test1的名字i，显然是不可行的。

以上这篇Python进阶_关于命名空间与作用域(详解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持本站。