函數的進階(命名空間和作業域, 函數的嵌套好作用域, 函數的本質, 和閉包)
一，引言
現在我有個問題，函數裏面的變量，在函數外面能直接引用麽？
def func1():
m = 1
print(m)
print(m) #這行報的錯
報錯了：
NameError: name ‘m‘ is not defined
上面為什麽會報錯呢？現在我們來分析一下python內部的原理是怎麽樣：
我們首先回憶一下Python代碼運行的時候遇到函數是怎麽做的，從Python解釋器開始執行之後，就在內存中開辟裏一個空間，每當遇到一個變量的時候，就把變量名和值之間對應的關系記錄下來，但是當遇到函數定義的時候，解釋器只是象征性的將函數名讀如內存，表示知道這個函數存在了，至於函數內部的變量和邏輯，解釋器根本不關心。
等執行到函數調用的時候，Python解釋器會再開辟一塊內存來儲存這個函數裏面的內容，這個時候，才關註函數裏面有哪些變量，而函數中的變量回儲存在新開辟出來的內存中，函數中的變量只能在函數內部使用，並且會隨著函數執行完畢，這塊內存中的所有內容也會被清空。
我們給這個‘存放名字與值的關系’的空間起了一個名字-------命名空間。
代碼在運行伊始，創建的存儲“變量名與值的關系”的空間叫做全局命名空間；
在函數的運行中開辟的臨時的空間叫做局部命名空間。
二，命名空間和作用域
>>> import this The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren‘t special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you‘re Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it‘s a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let‘s do more of those! python之禪
>>> import this The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren‘t special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you‘re Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it‘s a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let‘s do more of those! python之禪
在python之禪中提到過：命名空間是一種絕妙的理念，讓我們盡情的使用發揮吧！
命名空間一共分為三種：
全局命名空間
局部命名空間
內置命名空間
*內置命名空間中存放了python解釋器為我們提供的名字：input,print,str,list,tuple...它們都是我們熟悉的，拿過來就可以用的方法。
三種命名空間之間的加載與取值順序：
加載順序：內置命名空間(程序運行前加載)->全局命名空間(程序運行中：從上到下加載)->局部命名空間(程序運行中：調用時才加載)
取值順序：
在局部調用：局部命名空間->全局命名空間->內置命名空間
在全局調用：全局命名空間->內置命名空間
綜上所述，在找尋變量時，從小範圍，一層一層到大範圍去找尋。
作用域
作用域就是作用範圍，按照生效範圍可以分為全局作用域和局部作用域。
全局作用域：包含內置名稱空間、全局名稱空間，在整個文件的任意位置都能被引用、全局有效
局部作用域：局部名稱空間，只能在局部範圍內生效
globals和locals方法
print(globals()) print(locals())
print(globals()) print(locals())
def func():
a = 12
b = 20
print(locals())
print(globals())
func()
def func():
a = 12
b = 20
print(locals())
print(globals())
func()
global關鍵字，nonlocal關鍵字。
global：
1，聲明一個全局變量。
2，在局部作用域想要對全局作用域的全局變量進行修改時，需要用到 global(限於字符串，數字)。
def func():
global a
a = 3
func()
print(a)
count = 1
def search():
global count
count = 2
search()
print(count)
ps：對可變數據類型（list，dict，set）可以直接引用不用通過global。
li = [1,2,3]
dic = {‘a‘:‘b‘}
def change():
li.append(‘a‘)
dic[‘q‘] = ‘g‘
print(dic)
print(li)
change()
print(li)
print(dic)
nonlocal:
1，不能修改全局變量。
2，在局部作用域中，對父級作用域（或者更外層作用域非全局作用域）的變量進行引用和修改，並且引用的哪層，從那層及以下此變量全部發生改 變。
def add_b():
b = 42
def do_global():
b = 10
print(b)
def dd_nonlocal():
nonlocal b
b = b + 20
print(b)
dd_nonlocal()
print(b)
do_global()
print(b)
add_b()
三，函數的嵌套和作用域鏈
函數的嵌套調用
def max2(x,y):
m = x if x>y else y
return m
def max4(a,b,c,d):
res1 = max2(a,b)
res2 = max2(res1,c)
res3 = max2(res2,d)
return res3
# max4(23,-7,31,11)
函數的嵌套定義
def f1():
print("in f1")
def f2():
print("in f2")
f2()
f1()
###########
def f1():
def f2():
def f3():
print("in f3")
print("in f2")
f3()
print("in f1")
f2()
f1()
函數的作用域鏈：小範圍作用域可以使用大範圍的變量，但是反之不行，他是單向的。
def f1():
a = 1
def f2():
def f3():
print(a)
f3()
f2()
f1()
################
def f1():
a = 1
def f2():
a = 2
f2()
print(‘a in f1 : ‘,a)
f1()
四，函數名的本質。
函數名本質上就是函數的內存地址。
1.可以被引用
def func():
print(‘in func‘)
f = func
print(f)
2.可以被當作容器類型的元素
def f1():
print(‘f1‘)
def f2():
print(‘f2‘)
def f3():
print(‘f3‘)
l = [f1,f2,f3]
d = {‘f1‘:f1,‘f2‘:f2,‘f3‘:f3}
#調用
l[0]()
d[‘f2‘]()
3.可以當作函數的參數和返回值
def f1():
print(‘f1‘)
def func1(argv):
argv()
return argv
f = func1(f1)
f()
第一類對象（first-class object）指 1.可在運行期創建 2.可用作函數參數或返回值 3.可存入變量的實體
*不明白？那就記住一句話，就當普通變量用
五，閉包
def func():
name = ‘太白金星‘
def inner():
print(name)
閉包函數：
內部函數包含對外部作用域而非全劇作用域變量的引用，該內部函數稱為閉包函數
#函數內部定義的函數稱為內部函數
由於有了作用域的關系，我們就不能拿到函數內部的變量和函數了。如果我們就是想拿怎麽辦呢？返回呀！
我們都知道函數內的變量我們要想在函數外部用，可以直接返回這個變量，那麽如果我們想在函數外部調用函數內部的函數呢？
是不是直接就把這個函數的名字返回就好了？
這才是閉包函數最常用的用法
def func():
name = ‘eva‘
def inner():
print(name)
return inner
f = func()
f()
判斷閉包函數的方法__closure__
#輸出的__closure__有cell元素 ：是閉包函數
def func():
name = ‘eva‘
def inner():
print(name)
print(inner.__closure__)
return inner
f = func()
f()
#輸出的__closure__為None ：不是閉包函數
name = ‘egon‘
def func2():
def inner():
print(name)
print(inner.__closure__)
return inner
f2 = func2()
f2()
def wrapper():
money = 1000
def func():
name = ‘eva‘
def inner():
print(name,money)
return inner
return func
f = wrapper()
i = f()
i()
def wrapper():
money = 1000
def func():
name = ‘eva‘
def inner():
print(name,money)
return inner
return func
f = wrapper()
i = f()
i()
from urllib.request import urlopen
def index():
url = "http://www.xiaohua100.cn/index.html"
def get():
return urlopen(url).read()
return get
xiaohua = index()
content = xiaohua()
print(content)
from urllib.request import urlopen
def index():
url = "http://www.xiaohua100.cn/index.html"
def get():
return urlopen(url).read()
return get
xiaohua = index()
content = xiaohua()
print(content)
函數的進階(命名空間和作業域, 函數的嵌套好作用域, 函數的本質, 和閉包)