Python中的作用域與名字空間實例分析

這篇文章主要介紹“Python中的作用域與名字空間實例分析”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“Python中的作用域與名字空間實例分析”文章能幫助大家解決問題。

變量只是一個符號

從解釋器的角度來看，變量只是一個泛型指針 PyObject *；而從 Python 的角度來看，變量只是一個用來和對象進行綁定的名字、或者說符號。

變量的定義本質上就是建立名字和對象之間的約束關系，所以 a = 1 這個賦值語句本質上就是將 a 和 1 綁定起來，讓我們通過 a 這個符號可以找到對應的 PyLongObject。

除了變量賦值，創建函數、類也相當于定義變量，或者說完成名字和對象之間的綁定。

def foo(): pass

class A(): pass

創建一個函數也相當于定義一個變量，會先根據函數體創建一個函數對象，然后將符號 foo 和函數對象綁定起來。所以函數名和函數體之間是分離的，同理類也是如此。

import os

導入一個模塊，也是在定義一個變量。import os 相當于將名字 os 和模塊對象綁定起來，通過 os 可以找到指定的模塊對象。

再比如 import numpy as np 當中的 as 語句同樣是在定義變量，將名字 np 和對應的模塊對象綁定起來，以后就可以通過 np 這個名字去獲取指定的模塊了。

另外，當我們導入一個模塊的時候，解釋器是這么做的，比如 import os

它等價于 os = __import__("os")，可以看到本質上還是一個變量賦值語句。

變量的可見性

我們知道賦值語句、函數定義、類定義、模塊導入，本質上只是完成了名字和對象之間的綁定。而從概念上講，我們實際上就是得到了一個 name 和 obj 之間的映射關系，通過 name 可以獲取對應的 obj，而它們的容身之所就是名字空間。

那么要實現名字空間，應該選擇哪一種數據結構呢？毫無疑問，肯定是字典。而在前面介紹字典的時候，我們說字典是被高度優化的，原因就是虛擬機本身也在大量使用字典，從這里的名字空間即可得到體現。

但是一個模塊內部，名字（變量）還存在可見性的問題，比如：

number = 123

def foo():
    number = 456
    print(number)

foo()
print(number)  
"""
456
123
"""

我們看到同一個變量名，打印的確是不同的值，說明指向了不同的對象，換句話說這兩個變量是在不同的名字空間中被創建的。

因為名字空間是一個字典，如果兩者是在同一個名字空間，那么由于字典的 key 的不重復性，當執行 number = 456 的時候，會把字典里面 key 為 "number" 的 value 給更新成 456。但外面還是打印 123，這說明兩者所在的不是同一個名字空間，打印的也就自然不是同一個 number。

因此對于一個模塊而言，內部是可能存在多個名字空間的，每一個名字空間都與一個作用域相對應。作用域可以理解為一段程序的正文區域，在這個區域里面定義的變量是有意義的，然而一旦出了這個區域，就無效了。

對于作用域這個概念，至關重要的是要記住：它僅僅是由程序的文本所決定的。在 Python 中，一個變量在某個位置是否起作用，是由它的文本位置決定的。

因此 Python 具有靜態詞法作用域，而名字空間則是作用域的動態體現，一個由程序文本定義的作用域在 Python 運行時會轉化為一個名字空間（字典）。比如進入一個函數，顯然進入了一個新的作用域，因此函數在執行時，會創建一個名字空間。

Python 在對源代碼進行編譯的時候，對于代碼中的每一個 block，都會創建一個PyCodeObject 與之對應。而當進入一個新的名字空間、或者說作用域時，我們就算是進入一個新的 block 了。

而根據我們使用 Python 的經驗，顯然函數、類都是一個新的 block，當 Python 運行的時候會為它們創建各自的名字空間。

所以名字空間是名字（變量）的上下文環境，名字的含義取決于名字空間。更具體的說，一個變量綁定的對象是不確定的，需要由名字空間來決定。

位于同一個作用域的代碼可以直接訪問作用域中出現的名字，即所謂的直接訪問；但不同作用域，則需要通過訪問修飾符 . 進行屬性訪問。

class A:
    a = 1


class B:
    b = 2
    print(A.a)  # 1
    print(b)  # 2

如果想在 B 里面訪問 A 里面的內容，要通過A.屬性的方式，表示通過 A 來獲取 A 里面的屬性。但是訪問 B 的內容就不需要了，因為都是在同一個作用域，所以直接訪問即可。

訪問名字這樣的行為被稱為名字引用，名字引用的規則決定了 Python 程序的行為。

number = 123

def foo():
    number = 456
    print(number)

foo()
print(number)

還是上面的代碼，如果把函數里面的賦值語句給刪掉，那么再執行程序會有什么后果呢？從 Python 層面來看，由于函數的作用域里面沒有 number 這個變量，顯然會尋找外部的 number。因此我們可以得到如下結論：

• 作用域是層層嵌套的；

• 內層作用域可以訪問外層作用域；

• 外層作用域無法訪問內層作用域，盡管我們沒有試，但是想都不用想。如果是把外層的 number = 123 給去掉，那么最后面的 print(number) 鐵定報錯；

• 查找元素會依次從當前作用域向外查找，也就是查找元素時，對應的作用域是按照從小往大、從里往外的方向前進的；

LGB 規則

我們說函數、類有自己的作用域，但是模塊對應的源文件本身也有相應的作用域。比如：

name = "古明地覺"
age = 16

def foo():
    return 123

class A:
    pass

由于文件本身也有自己的作用域，顯然是 global 作用域，所以解釋器在運行這個文件的時候，也會為其創建一個名字空間，而這個名字空間就是 global 名字空間。它里面的變量是全局的，或者說是模塊級別的，在當前文件的任意位置都可以直接訪問。

而函數也有作用域，這個作用域稱為 local 作用域，對應 local 名字空間；同時 Python 自身還定義了一個最頂層的作用域，也就是 builtin 作用域，像內置函數、內建對象都在 builtin 里面。

這三個作用域在Python2.2之前就存在了，所以那時候Python的作用域規則被稱之為LGB規則：名字引用動作沿著local作用域(local名字空間)、global作用域(global名字空間)、builtin作用域(builtin名字空間)來查找對應的變量。

而獲取名字空間，Python也提供了相應的內置函數：

• locals 函數：獲取當前作用域的 local 名字空間，local 名字空間也稱為局部名字空間；

• globals 函數：獲取當前作用域的 global 名字空間，global 名字空間也稱為全局名字空間；

• __builtins__函數：或者 import builtins，獲取當前作用域的 builtin 名字空間，builtint 名字空間也稱為內置名字空間；

每個函數都有自己 local 名字空間，因為不同的函數對應不同的作用域，但是 global 名字空間則是全局唯一。

name = "古明地覺"

def foo():
    pass

print("name" in globals())
print("foo" in globals())
"""
True
True
"""

但是注意，我們說 foo 也是一個獨立的 block，因此它會對應一個 PyCodeObject。但是在解釋到 def foo 的時候，會根據這個 PyCodeObject 對象創建一個 PyFunctionObject對象，然后將字符串 foo 和這個函數對象綁定起來。

當調用 foo 的時候，再根據 PyFunctionObject 對象創建 PyFrameObject 對象、然后執行，這些留在介紹函數的時候再細說。但是我們看到 foo 也是一個全局變量，全局變量都在 global 名字空間中。

總之，global名字空間全局唯一，它是程序運行時的全局變量和與之綁定的對象的容身之所，你在任何一個地方都可以訪問到 global 名字空間。正如，你在任何一個地方都可以訪問相應的全局變量一樣。

此外，我們說名字空間是一個字典，變量和對象會以鍵值對的形式存在里面。那么換句話說，如果我手動地往這個 global 名字空間里面添加一個鍵值對，是不是也等價于定義一個全局變量呢？

globals()["name"] = "古明地覺"
print(name)  # 古明地覺

def f1():
    def f2():
        def f3():
            globals()["age"] = 16
        return f3
    return f2


f1()()()
print(age)  # 16

我們看到確實如此，通過往 global 名字空間里面插入一個鍵值對完全等價于定義一個全局變量。并且 global 名字空間是唯一的，你在任何地方調用 globals() 得到的都是 global 名字空間，正如你在任何地方都可以訪問到全局變量一樣。

所以即使是在函數中向 global 名字空間中插入一個鍵值對，也等價于定義一個全局變量、并和對象綁定起來。

• name="xxx" 等價于 globals["name"]="xxx";

• print(name) 等價于 print(globals["name"])；

對于 local 名字空間來說，它也對應一個字典，顯然這個字典就不是全局唯一的了，每一個局部作用域都會對應自身的 local 名字空間。

def f():
    name = "古明地覺"
    age = 16
    return locals()


def g():
    name = "古明地戀"
    age = 15
    return locals()


print(locals() == globals())  # True
print(f())  # {'name': '古明地覺', 'age': 16}
print(g())  # {'name': '古明地戀', 'age': 15}

顯然對于模塊來講，它的local名字空間和global名字空間是一樣的，也就是說，模塊對應的 PyFrameObject 對象里面的 f_locals 和 f_globals 指向的是同一個 PyDictObject 對象。

但是對于函數而言，局部名字空間和全局名字空間就不一樣了。調用 locals 是獲取自身的局部名字空間，而不同函數的 local 名字空間是不同的。但是 globals 函數的調用結果是一樣的，獲取的都是 global 名字空間，這也符合函數內找不到某個變量的時候會去找全局變量這一結論。

所以我們說在函數里面查找一個變量，查找不到的話會找全局變量，全局變量再沒有會查找內置變量。本質上就是按照自身的 local 空間、外層的 global 空間、內置的 builtin 空間的順序進行查找。

因此 local 空間會有很多個，因為每一個函數或者類都有自己的局部作用域，這個局部作用域就可以稱之為該函數的 local 空間；但是 global 空間則全局唯一，因為該字典存儲的是全局變量。無論你在什么地方，通過調用 globals 函數拿到的永遠是全局名字空間，向該空間中添加鍵值對，等價于創建全局變量。

對于 builtin 名字空間，它也是一個字典。當 local 空間、global 空間都沒有的時候，會去 builtin 空間查找。那么 builtin 名字空間如何獲取呢？答案是使用 builtins 模塊，通過 builtins.__dict__ 即可拿到 builtin 名字空間。

# 等價于__builtins__
import builtins

#我們調用 list 顯然是從內置作用域、也就是 builtin 名字空間中查找的
#但我們只寫 list 也是可以的
#因為 local 空間、global 空間沒有的話，最終會從 builtin 空間中查找
#但如果是 builtins.list，那么就不兜圈子了
#表示: "builtin 空間，就從你這獲取了"
print(builtins.list is list)  # True

builtins.dict = 123
#將 builtin 空間的 dict 改成 123
#那么此時獲取的 dict 就是123
#因為是從內置作用域中獲取的
print(dict + 456)  # 579

str = 123
#如果是 str = 123，等價于創建全局變量 str = 123
#顯然影響的是 global 空間
print(str)  # 123
# 但是此時不影響 builtin 空間
print(builtins.str)  # <class 'str'>

這里提一下Python2當中，while 1比while True要快，為什么？

因為 True 在 Python2 中不是關鍵字，所以它是可以作為變量名的。那么 Python 在執行的時候就要先看 local 空間和 global 空間里有沒有 True 這個變量，有的話使用我們定義的，沒有的話再使用內置的 True。

而 1 是一個常量，直接加載就可以，所以 while True 多了符號查找這一過程。但是在 Python3 中兩者就等價了，因為 True 在 Python3 中是一個關鍵字，也會直接作為一個常量來加載。

局部變量是靜態存儲的

我們往 global 空間添加一個鍵值對相當于定義一個全局變量，那么如果往函數的 local 空間里面添加一個鍵值對，是不是也等價于創建了一個局部變量呢？

def func():
    locals()["where"] = "地靈殿"
    try:
        print(where)
    except Exception as e:
        print(e)

func()  # name 'where' is not defined

對于全局變量來講，變量的創建是通過向字典添加鍵值對的方式實現的。因為全局變量會一直在變，需要使用字典來動態維護。

但對于函數來講，內部的變量是通過靜態方式存儲和訪問的，因為局部作用域中存在哪些變量在編譯的時候就已經確定了，我們通過 PyCodeObject 的 co_varnames 即可獲取內部都有哪些變量。

所以，雖然我們說遍歷查找是按照 LGB 的方式，但是訪問函數內部的變量其實是靜態訪問的，不過完全可以按照 LGB 的方式理解。關于這方面的細節，后續還會細說。

因此名字空間是 Python 的靈魂，它規定了 Python 變量的作用域，使得 Python 對變量的查找變得非常清晰。

LEGB 規則

前面說的 LGB 是針對 Python2.2 之前的，而從 Python2.2 開始，由于引入了嵌套函數，所以最好的方式應該是內層函數找不到某個變量時先去外層函數找，而不是直接就跑到 global 空間里面找。那么此時的規則就是LEGB：

a = 1

def foo():
    a = 2

    def bar():
        print(a)
    return bar

f = foo()
f()
"""
2
"""

調用 f，實際上調用的是函數 bar，最終輸出的結果是 2。如果按照 LGB 的規則來查找的話，由于函數 bar 的作用域沒有 a，那么應該到全局里面找，打印的結果是 1 才對。

但我們之前說了，作用域僅僅是由文本決定的，函數 bar 位于函數 foo 之內，所以函數 bar 定義的作用域內嵌于函數 foo 的作用域之內。換句話說，函數 foo 的作用域是函數 bar 的直接外圍作用域。

所以應該先從 foo 的作用域里面找，如果沒有那么再去全局里面找。而作用域和名字空間是對應的，名字空間是作用域的動態體現，所以最終打印了 2。

另外在執行 f = foo() 的時候，會執行函數 foo 中的 def bar(): 語句，這個時候解釋器會將 a=2 與函數 bar 捆綁在一起，然后返回，這個捆綁起來的整體就叫做閉包。

所以：閉包 = 內層函數 + 引用的外層作用域的變量

這里顯示的規則就是 LEGB，其中 E 表示 enclosing，代表直接外圍作用域。

global 表達式

有一個很奇怪的問題，最開始學習 Python 的時候，估計很多人都為此感到困惑，下面來看一下。

a = 1

def foo():
    print(a)

foo()
"""
1
"""

首先這段代碼打印 1，這顯然是沒有問題的，不過下面問題來了。

a = 1

def foo():
    print(a)
    a = 2

foo()
"""
UnboundLocalError: local variable 'a' referenced before assignment
"""

僅僅是在 print 語句后面新建了一個變量 a，結果就報錯了，提示局部變量 a 在賦值之前就被引用了，這是怎么一回事，相信肯定有人為此困惑。而想弄明白這個錯誤的原因，需要深刻理解兩點：

一個賦值語句所定義的變量，在這個賦值語句所在的整個作用域內都是可見的；

函數中的變量是靜態存儲、靜態訪問的, 內部有哪些變量在編譯的時候就已經確定；

在編譯的時候，因為存在 a = 2 這條語句，所以知道函數中存在一個局部變量 a，那么查找的時候就會在當前作用域中查找。但是還沒來得及賦值，就 print(a) 了，所以報錯：局部變量a在賦值之前就被引用了。但如果沒有 a = 2 這條語句則不會報錯，因為知道局部作用域中不存在 a 這個變量，所以會找全局變量 a，從而打印 1。

更有趣的東西隱藏在字節碼當中，我們可以通過反匯編來查看一下：

import dis

a = 1

def g():
    print(a)
    
dis.dis(g)
"""
  7           0 LOAD_GLOBAL              0 (print)
              2 LOAD_GLOBAL              1 (a)
              4 CALL_FUNCTION            1
              6 POP_TOP
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
"""

def f():
    print(a)
    a = 2

dis.dis(f)
"""
 12           0 LOAD_GLOBAL              0 (print)
              2 LOAD_FAST                0 (a)
              4 CALL_FUNCTION            1
              6 POP_TOP

 13           8 LOAD_CONST               1 (2)
             10 STORE_FAST               0 (a)
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE
"""

中間的序號代表字節碼的偏移量，我們看第二條，g 的字節碼是 LOAD_GLOBAL，意思是在 global 名字空間中查找；而 f 的字節碼是LOAD_FAST，表示靜態查找。因此結果說明 Python 采用了靜態作用域策略，在編譯的時候就已經知道了名字藏身于何處。

而且上面的例子也表明，一旦函數內有了對某個名字的賦值操作，這個名字就會在作用域內可見，就會出現在 local 名字空間中。換句話說，會遮蔽外層作用域中相同的名字。

當然 Python 也為我們精心準備了 global 關鍵字，讓我們在函數內部修改全局變量。比如函數內部出現了 global a，就表示我后面的 a 是全局的，直接到 global 名字空間里面去找，不要在 local 空間里面找了。

a = 1

def bar():
    def foo():
        global a
        a = 2
    return foo

bar()()
print(a)  # 2
# 當然，也可以通過 globals 函數拿到名字空間
# 然后直接修改里面的鍵值對

但如果外層函數里面也出現了變量 a，而我們想修改的也是外層函數的 a、不是全局的 a，這時該怎么辦呢？Python 同樣為我們準備了關鍵字 nonlocal，但是使用 nonlocal 的時候，必須是在內層函數里面。

a = 1

def bar():
    a = 2
    def foo():
        nonlocal a
        a = "xxx"
    return foo

bar()()
print(a)  # 1
# 外界依舊是 1，但是 bar 里面的 a 已經被修改了

屬性空間

我們知道，自定義的類里面如果沒有 __slots__，那么這個類的實例對象都會有一個屬性字典。

class Girl:

    def __init__(self):
        self.name = "古明地覺"
        self.age = 16


g = Girl()
print(g.__dict__)  # {'name': '古明地覺', 'age': 16}

# 對于查找屬性而言, 也是去屬性字典中查找
print(g.name, g.__dict__["name"])  # 古明地覺 古明地覺

# 同理設置屬性, 也是更改對應的屬性字典
g.__dict__["gender"] = "female"
print(g.gender)  # female

當然模塊也有屬性字典，本質上和普通的類的實例對象是一致的。

import builtins

print(builtins.str)  # <class 'str'>
print(builtins.__dict__["str"])  # <class 'str'>

# 另外，有一個內置的變量 __builtins__，和導入的 builtins 等價
print(__builtins__ is builtins)  # True

另外這個 __builtins__ 位于 global 名字空間里面，然后獲取 global 名字空間的 globals 又是一個內置函數，于是一個神奇的事情就出現了。

print(globals()["__builtins__"].globals()["__builtins__"].
      globals()["__builtins__"].globals()["__builtins__"].
      globals()["__builtins__"].globals()["__builtins__"]
      )  # <module 'builtins' (built-in)>

print(globals()["__builtins__"].globals()["__builtins__"].
      globals()["__builtins__"].globals()["__builtins__"].
      globals()["__builtins__"].globals()["__builtins__"].list("abc")
      )  # ['a', 'b', 'c']

所以 global 名字空間和 builtin 名字空間，都保存了指向彼此的指針，不管套娃多少次，都是可以的。

關于“Python中的作用域與名字空間實例分析”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。