如非特別說明,下文皆基於
Python3
命名空間與作用於跟名字的綁定相關性很大,可以結合另一篇介紹Python
名字、對象及其綁定的文章。
Namespace
命名空間,也稱為名字空間,是從名字到物件的對應。在 Python
中,大部分的命名空間都是由字典來實現的,但本文的不會涉及命名空間的實作。
命名空間的一大作用是避免名字衝突:
def fun1(): i = 1def fun2(): i = 2
同一個模組中的兩個#在##函數中,兩個同名名字i之間絕對沒有任何關係,因為它們分屬於不同明明空間。
#built-in名字集合,包括像
abs()這樣的函數,以及內建的例外名字等。通常,使用
內建這個字表示這個命名空間-內建命名空間
全域命名空間表示。
局部命名空間表示。
屬性集合,也構成了一個命名空間。但通常使用objname.attrname的間接方式存取屬性,而不是直接訪問,故不將其列入命名空間討論。
class<a href="http://www.php.cn/wiki/164.html" target="_blank"> ClassName:</a>語句,會新建一個命名空間。 (請參閱官方對類別定義的說明)
Python解釋器啟動時創建,解釋器
退出時銷毀;
的一塊文字區域,這個區域中,命名空間可以被「直接存取」。這裡的直接存取指的是試圖在命名空間中找到名字的絕對引用
(非限定參考)。這裡有必要解釋下直接引用和間接引用:
,這種方式嘗試在名字空間中搜尋
名字name。
的方式,即屬性引用,這種方式不會在命名空間中搜尋名字attrname
,而是搜尋名字objname
,再存取其屬性。
的一塊文字區域,也就是一塊程式碼區域,需要程式碼區域引用名字(存取 顾名思义,名字作用域就是名字可以影响到的代码文本区域,命名空间的作用域就是这个命名空间可以影响到的代码文本区域。那么也存在这样一个代码文本区域,多个命名空间可以影响到它。 那么,可以这样认为: 静态的作用域,是一个或多个命名空间按照一定规则叠加影响代码区域;运行时动态的作用域,是按照特定层次组合起来的命名空间。 在一定程度上,可以认为动态的作用域就是命名空间。在后面的表述中,我会把动态的作用域与其对应命名空间等同起来。 在程序中引用了一个名字, 在程序运行时,至少存在三个命名空间可以被直接访问的作用域: Local Enclosing Global Built-in 程序运行时, 局部作用域在哪里呢?我们认为(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进阶 - 对象,名字以及绑定》中介绍过, 打破第一编程语言认知的第二门编程语言,才是值得去学的好语言。 我不太想用“变量”这个词形容名字,奈何变量是家喻户晓了, If a variable is used in a code block but not defined there, it is a free variable. 如果引用发生的代码块不是其定义的地方,它就是一个自由变量。专业一点,就是: 引用名字的作用域中没有这个名字,那这个名字就是自由名字 Note: “自由名字”只是作者YY的,并没得到广泛认可。 我们已经了解了作用域有 很清楚,这段代码的输出是 很遗憾,最后的打印语句没有按照期待打印出 A special quirk of Python is that – if no global statement is in effect – assignments to names always go into the innermost scope. 当涉及可变对象时,情况又有所不同了: 很遗憾,最后的打印语句没有按照期待输出 注意,下面的示例跟上面的是不一样的: 我们可以用本节中示例1的方法解释它。 综上,可以认为: 自由变量可读不可写。 总是存在打破规则的需求: 在低层作用域中需要重绑定高层作用域名字,即通过自由名字重绑定。 于是 global_stmt ::= "global" identifier ("," identifier)* nonlocal_stmt ::= "nonlocal" identifier ("," identifier)* 经典的官方示例: 作者说不行 Output: 作者曾经自信满满认为透彻了解了 Output: 其实忽略掉全局作用域中 Usually, the local scope references the local names of the (textually) current function. 我就问问大家,这个输出什么? 上文强调过: 类定义开始时,创建新的属于类的命名空间,用作局部作用域。类定义完后,命名空间销毁,没有直接方法访问到类中的 方法调用的本质是函数调用: 函数调用开始,其作用域与全局作用域有了上下级关系( 直接引用:试图直接写名字 间接引用:使用 一个正常列表推导式: 现在把列表推导式放到类中: Output: 输出反馈名字 上文强调过,解释器读取类定义开始 既然是两个独立局部作用域,那么上述例子就等同于: 期待在 Python Scopes and Namespaces Python命名空间和作用域窥探 Python的作用域 Naming and binding 以上是Python命名空間與作用域的詳細內容。更多資訊請關注PHP中文網其他相關文章!變數
),那麼必然作用域與命名空間之間就有了連結。
作用域只是文本区域,其定义是静态的;而名字空间却是动态的,只有随着解释器的执行,命名空间才会产生。那么,在静态的作用域中访问动态命名空间中的名字,造成了作用域使用的动态性。2.3 名字搜索规则
Python
是怎样搜索到这个名字呢?
首先搜索,包含局部名字的最内层(innermost)作用域,如函数/方法/类的内部局部作用域;
根据嵌套层次从内到外搜索,包含非局部(nonlocal)非全局(nonglobal)名字的任意封闭函数的作用域。如两个嵌套的函数,内层函数的作用域是局部作用域,外层函数作用域就是内层函数的 Enclosing作用域;
倒数第二次被搜索,包含当前模块全局名字的作用域;
最后被搜索,包含内建名字的最外层作用域。LGB
三个作用域是一定存在的,E
作用域不一定存在;若程序是这样的:i = 1print(i)
Python
按照以上L-E-G-B
的顺序依次在四个作用域搜索名字。没有搜索到时,Python
抛出NameError
异常。2.4 何时引入作用域
Python
中一个名字只有在定义之后,才能引用。print(i)
i
,按照搜索规则,在LGB
三个作用域均没有搜索到名字i
(LB
相同命名空间)。抛出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 = 1try_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
作用域;local
作用域,传说在python2
中列表推导式不引入新的作用域<a href="http://www.php.cn/wiki/109.html" target="_blank">if</a>
语句:if True:
i = 1print(i) # output: 1,而不是NameError
if
语句并不会引入新的作用域,所以名字绑定语句i = 1
与print(i)
是在同一个作用域中。<a href="http://www.php.cn/wiki/125.html" target="_blank">for</a>
语句:for i in range(6): passprint(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
语句在函数import_sys
中将名字sys
和对应模块绑定,那sys
这个名字还是定义在局部作用域,跟上面的例子没有任务区别。要时刻切记Python
的名字,对象,这个其他编程语言不一样,但是:3. 作用域应用
3.1 自由变量可读不可写
Python
中的自由变量: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
。Python
的一个怪癖是,如果没有使用global
语句,对名字的赋值语句通常会影响最内层作用域。
即赋值语句影响局部作用域,赋值语句带来的影响是绑定或重绑定,但是在当前局部作用域的命名空间中,并没有s
这个名字,因此赋值语句在局部作用于定义了同名名字s
,这与外层作用域中的s
并不冲突,因为它们分属不同命名空间。
这样,全局作用域的s
没有被重绑定,结果就很好解释了。
[示例3]def low_scope():
l[0] = 2l = [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]
3.2
global
和nonlocal
global
语句和nonlocal
语句因运而生。
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
关键字绑定全局名字是不可能的。
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 spamscope_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()
File "scope_test.py", line 41
nonlocal spam1SyntaxError: no binding for nonlocal 'spam1' found
4. 一些坑
Python
的作用域,但是一大堆坑踩得触不及防。4.1 坑1 - UnboundLocalError
def test(): print(i)
i = 1i = 2test()
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
这条语句,都可以理解。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 = 2t.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 = 1b = [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
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
语句b = [a + i for i in rage(10)]
,列表推导式同样创建了一个局部作用域。这个作用域与类定义的局部作用域并没有上下级关系,所以,自然没有任何直接访问名字a
的方法。Python
中只有四种作用域:LEGB
,因为类定义的局部作用域与列表推导式的局部作用域于不是嵌套函数关系,所以并不能构成Enclosing
作用域关系。因此它们是两个独立的局部作用域,不能相互访问。def test1():
i = 1def test2(): print(i)
test1()
test2()
test2
中访问test1
的名字i
,显然是不可行的。参考