全域空間和區域空間

命名空間

命名空間的概念的提出是為了劃分和控制變數是否可見，以及生存周期的長短；命名空間的作用范圍叫做作用域，

劃分一塊區域保存所有資料，以字典的方式存盤（變數與值形成映射關系），一共三種，

1. 內建命名空間：
   • 解釋器啟動時創建，直到解釋器運行結束，生存周期最長；
2. 全域命名空間：
   • 檔案運行時創建，直到解釋器運行結束，生存周期較長；
3. 區域命名空間：
   • 數呼叫時，里面的區域變數才創建，呼叫結束后即釋放，生存周期較短；

創建和銷毀順序

• 創建順序：
  • python解釋器啟動->創建內建命名空間->創建全域命名空間->創建區域命名空間
• 銷毀順序：
  • 函式呼叫結束后->銷毀函式對應的區域命名空間資料->銷毀全域命名空間資料->銷毀內建命名空間資料

全域變數和區域變數

什么是全域和區域變數

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

# 在函式中創建的變數就是區域變數
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中自帶的、內置的函式，

作用域

區域變數作用域：在函式的內部

全域變數作用域：橫跨整個檔案

生命周期

內置變數 -> 全域變數 -> 區域變數

內置變數自python程式運行的時候開始，一直等到python程式結束之后才會釋放；

全域變數自創建開始，一直到程式結束或者被清除才會釋放；

區域變數字創建開始，一直到區域空間執行結束或者清除就會釋放；

全域部函式和關鍵字的使用

函式

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)  # 區域環境中修改

函式的嵌套

在學習nonlocal之前我們需要先學習一些關于函式嵌套的知識，

內函式和外函式

函式之間是可以互相嵌套的，外層的叫做外函式，內層的叫做內函式，

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

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

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


# 執行外函式
outer()

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

1. 內函式不可以直接在外函式外執行呼叫
2. 呼叫外函式后，內函式也不可以在函式外部呼叫
3. 內函式只可以在外函式的內部呼叫
4. 內函式在外函式內部呼叫時，有先后順序，必須先定義在呼叫，因為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()

總結

全域變數和區域變數

區域環境中可以呼叫全域變數，但是不能修改（但是如果全域變數是可變資料則可以修改其中的值）
全域環境中不能呼叫區域變數 也不能修改

函式

global()

（在函式內部使用，可以對全域變數進行操作）
1、可以在區域環境中定義全域變數
2、可以在區域環境中修改全域變數

nonlocal()

（在內函式中使用，可以在內函式中修改外函式中的區域變數）

關鍵字

locals

1、locals獲取當前作用域當中所有的變數
如果在全域呼叫locals之后，獲取的是列印之前的所有變數，回傳字典，全域作用域
如果在區域呼叫loclas之后，獲取的是呼叫之前的所有變數，回傳字典，區域作用域

globals

2、globals只獲取全域空間中的所有變數
如果在全域呼叫globals之后，獲取的是列印之前的所用變數，回傳字典，全域作用域
如果在區域呼叫globals之后，獲取的是呼叫之前的所用變數，回傳字典，全域作用域

標籤：其他

上一篇：Java基礎

下一篇：Go xmas2020 全英課程 08 學習筆記、Functions, Parameters & Defer