Python 全域性空間和區域性空間

2022-04-06 19:03:15

一、空間和區域性空間

1、名稱空間

名稱空間的概念的提出是為了劃分和控制變數是否可見，以及生存週期的長短；名稱空間的作用範圍叫做作用域。
劃分一塊區域儲存所有資料，以字典的方式儲存（變數與值形成對映關係）。一共三種。

內建名稱空間：
直譯器啟動時建立，直到直譯器執行結束，生存週期最長；
全域性名稱空間：
檔案執行時建立，直到直譯器執行結束，生存週期較長；
區域性名稱空間：
數呼叫時，裡面的區域性變數才建立，呼叫結束後即釋放，生存週期較短；
建立和銷燬順序
建立順序：
python直譯器啟動->建立內建名稱空間->建立全域性名稱空間->建立區域性名稱空間
銷燬順序：
函數呼叫結束後->銷燬函數對應的區域性名稱空間資料->銷燬全域性名稱空間資料->銷燬內建名稱空間資料

2、全域性變數和區域性變數

什麼是全域性和區域性變數：

區域性變數就是在函數內部定義的變數，區域性變數所在的就是區域性名稱空間，作用域僅僅在函數內部可見，也就是說只能在函數內部使用。

# 在函數中建立的變數就是區域性變數
def func():
   var = '區域性變數'

# 區域性變數不可以在非對應區域性環境中使用
print(var)  # error, 該變數不存在

全域性變數就是在函數外部定義的或者使用global在函數內部定義的變數，全域性變數所在的名稱空間就是全域性名稱空間，作用域橫跨整個檔案，就是說在整個檔案中的任何一個地方都可以使用全域性變數。

# 在全域性環境中建立的變數就是全域性變數
var = '全域性變數'

def func():
    # 在區域性中也可以使用全域性變數
    print(var)  # 全域性變數

func()

區域性變數最好不要和全域性變數同名，如果同名，在區域性環境中就無法使用全域性變數了。

var = '全域性變數'

def func():
    # 先使用了全域性變數
    print(var)  # error, 找不到該變數
        # 然後區域性變數和全域性變數同名，那麼新的區域性變數就會在區域性空間中覆蓋了全域性變數的一切影響力，這就叫做區域性變數修改了全域性變數；
    # 這樣的話導致在區域性空間中無法在使用該全域性變數，之前在區域性空間中使用的該變數就成為了先呼叫後定義；導致出錯。
    var = '區域性變數'
    print(var)

func()

# 但是區域性同名變數不會影響到全域性變數的值
print(var)  # 全域性變數

內建函數就是內建名稱空間，指的是那些python中自帶的、內建的函數。

3、作用域

區域性變數作用域：在函數的內部
全域性變數作用域：橫跨整個檔案

4、生命週期

內建變數 -> 全域性變數 -> 區域性變數
內建變數自python程式執行的時候開始，一直等到python程式結束之後才會釋放；
全域性變數自建立開始，一直到程式結束或者被清除才會釋放；
區域性變數字建立開始，一直到區域性空間執行結束或者清除就會釋放；

5、全域性部函數和關鍵字的使用

函數

globals()

返回所有的全域性作用域中的內容。
如果在全域性，呼叫globals之後，獲取的是列印之前的所有變數，返回字典，全域性空間作用域；

# 定義一些全域性變數
a, b, c = 1, 2, 3

# 呼叫globals函數
res = globals()

# 第一次列印，包含a b c
print(res)
'''
結果：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002DBDCA5D198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'res': {...}}
'''


# 再定義一些變數
d, e, f = 1, 2, 3

# 第二次列印，包含a b c d e f
print(res)
'''
結果：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002DBDCA5D198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'res': {...}, 'd': 1, 'e': 2, 'f': 3}
'''

如果在區域性，呼叫globals之後，獲取的是呼叫之前的所用變數，返回字典，全域性空間作用域；

# 定義一些全域性變數
a, b, c = 1, 2, 3


# 在區域性環境中使用globals函數
def func():
    res = globals()
    print(res)


# 呼叫函數
func()
'''
結果：不包含 d e f
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001E7C287D198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'func': <function func at 0x000001E7C2772F28>}
'''


# 再定義一些全域性變數
d, e, f = 4, 5, 6

# 第二次呼叫函數
func()
'''
結果：包含 d e f
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000021A3F3DD198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'func': <function func at 0x0000021A3F2D2F28>, 'd': 4, 'e': 5, 'f': 6}
'''

globals可以動態建立全域性變數

dic = globals()

print(dic)  # 返回系統的字典
'''
結果：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000026F357ED198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'dic': {...}}
'''


# 在全域性的字典當中，通過新增鍵值對，自動建立全域性變數，對應的鍵是變數名，對應的值是變數指向的值
dic['msr123123123'] = '123456'

print(msr123123123) # 123456

# 檢視全域性內容
print(dic)
'''
結果：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000161D944D198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/0-project/python/mymsr/ceshi/test6.py', '__cached__': None, 'dic': {...}, 'msr123123123': '123456'}
'''

locals()

返回當前所在作用域的所有內容。
如果在全域性，呼叫locals之後，獲取的是列印之前的所有變數，返回字典，全域性空間作用域；

# 定義一些全域性變數
a, b, c = 1, 2, 3

# 呼叫locals函數
res = locals()

# 第一次列印，包含a b c
print(res)
'''
結果：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000018C82A3D198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/0-project/python/mymsr/ceshi/test1.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'res': {...}}
'''


# 再定義一些變數
d, e, f = 1, 2, 3

# 第二次列印，包含a b c d e f
print(res)
'''
結果：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000018C82A3D198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/0-project/python/mymsr/ceshi/test1.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'res': {...}, 'd': 1, 'e': 2, 'f': 3}
'''

如果在區域性，呼叫locals之後，獲取的是呼叫之前的所有變數，返回字典，區域性空間作用域；

# 定義一些區域性變數
def func():
   # 區域性變數
   aa, bb, cc = 11, 22, 33

   # 第一遍呼叫
   res = locals()

   # 第一次列印，包含 aa bb cc
   print(res)  # {'cc': 33, 'bb': 22, 'aa': 11}

   # 再定義一些區域性變數
   dd, ee, ff = 44, 55, 66

   # 第二次列印，不包含 dd ee ff
   print(res)  # {'cc': 33, 'bb': 22, 'aa': 11}

   # 呼叫第二遍
   res2 = locals()

   # 列印第一次的呼叫，包含 dd ee ff
   print(res)  # {'cc': 33, 'bb': 22, 'aa': 11, 'ff': 66, 'ee': 55, 'dd': 44, 'res': {...}}
   
   # 列印第二次的呼叫，包含 dd ee ff
   print(res2) # {'cc': 33, 'bb': 22, 'aa': 11, 'ff': 66, 'ee': 55, 'dd': 44, 'res': {...}}

# 呼叫函數，返回在函數中的區域性變數
func()

關鍵字

global

在區域性環境中建立的變數是區域性變數，在全域性環境中是不可以使用的。但是使用global定義的變數就是一個全域性變數，這個變數可以全域性環境中使用。

def func():
    var = '區域性變數'

    global glvar
    glvar = '全域性變數'

# 一定要執行區域性環境喲
func()

# 全域性環境中
print(var)  # error，區域性變數不能呼叫
# 使用global定義的變數是全域性變數
print(glvar)    # 全域性變數

在區域性環境中無法修改全域性變數的值，使用global可以在區域性環境中修改全域性變數。

var = '全域性變數'

def func():
    global var
    var = '區域性環境中修改'

func()

print(var)  # 區域性環境中修改

6、函數的巢狀

在學習nonlocal之前我們需要先學習一些關於函數巢狀的知識。

內函數和外函數

函數之間是可以互相巢狀的，外層的叫做外函數，內層的叫做內函數。

def outer():
    print('我叫outer，是外函數')

    def inner():
        print('我叫inner，在outer的裡面，是內函數')

    # 在外函數中執行內函數
    inner()


# 執行外函數
outer()

'''
結果：
我叫outer，是外函數
我叫inner，在outer的裡面，是內函數
'''

內函數不可以直接在外函數外執行呼叫
呼叫外函數後，內函數也不可以在函數外部呼叫
內函數只可以在外函數的內部呼叫
內函數在外函數內部呼叫時，有先後順序，必須先定義在呼叫，因為python沒有預讀機制，這個預讀機制適用於python中的所有場景。

# 外層是outer，內層是inner，最裡層是smaller，呼叫smaller裡的所有程式碼
def outer():
    print('我叫outer，是最外層函數，是inner和smaller的外函數')

    def inner():
        print('我叫inner，是outer的內函數，是smaller的外函數')

        def smaller():
            print('我叫smaller，是outer和inner的內函數')

        # 先在inner中執行smaller
        smaller()

    # 然後在outer中執行inner
    inner()

# 最後再執行outer才能執行smaller函數
outer()

'''
結果：
我叫outer，是最外層函數，是inner和smaller的外函數
我叫inner，是outer的內函數，是smaller的外函數
我叫smaller，是outer和inner的內函數
'''

我們在多個函數巢狀的時候要注意，不管外函數還是內函數，都是函數，只要是函數中的變數都是區域性變數。
內涵可以使用外函數的區域性變數，外函數不能直接使用內函數的區域性變數。

二、LEGB原則

LEGB原則就是一個就近找變數原則，依據就近原則，從下往上，從裡向外，依次尋找。

B————Builtin（Python）：Python內建模組的名稱空間（內建作用域）
G————Global（module）：函數外部所在的名稱空間（全域性作用域）
E————Enclosing Function Locals：外部巢狀函數的作用域（巢狀作用域）
L————Local（Function）：當前函數內的作用域（區域性作用域）

nonlocal

現在我們正式學習nonlocal關鍵字，nonlocal的作用是修改當前區域性環境中上一層的區域性變數。那麼我們根據這個作用便知道了nonlocal的使用環境至少是一個二級的巢狀環境，且外層的區域性環境中必須存在一個區域性變數。

def outer():
    # 定義變數
    lvar = 'outer var'

    def inner():
        # 內函數使用nonlocal修改上一層的區域性變數
        nonlocal lvar
        lvar = 'inner var'

    # 執行inner函數
    inner()
    print(lvar)

outer() # inner var

假如上一層的區域性環境中沒有這個變數怎麼辦，那麼就根據LEGB原則向上尋找。

def outer():
    # 定義變數
    lvar = 'outer var'

    def inner():
        
        def smaller():
            
            # smaller中修改變數，但是inner中沒有，就向上尋找修改outer中的變數
            nonlocal lvar
            lvar = 'smaller var'

        # 執行 smaller函數
        smaller()

    # 執行inner函數
    inner()
    print(lvar)

# 執行outer函數
outer()

如果層層尋找，直到最外層的函數中也沒有這個變數，那麼就會報錯，因為nonlocal只會修改區域性變數，如果超出範圍，就會報錯。

var = 1  # 變數在最外層的函數之外，也就是全域性變數，nonlocal無法修改

def outer():

   def inner():

      def smaller():

         nonlocal var    # error，沒有區域性變數
         var = 2
         print(var)

      smaller()

   inner()

outer()