Python—函數進階

楔子

假若有一個函數，實現返回兩個數中的較大值：

def my_max(x,y): m = x if x>y else y return m
bigger = my_max(10,20)
print(bigger)

以前是否是我告訴大家要把結果return回來大家就照作了？但是大家有沒有想過，咱們爲何要把結果返回？若是咱們不返回m，直接在程序中打印，行不行？

來看結果：

>>> def my_max(x,y): ... m = x if x>y else y ... >>> my_max(10,20) >>> print(m) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'm' is not defined

報錯了！錯誤是「name 'm' is not defined」。變量m沒有被定義。。。爲啥？我明明定義了呀！

在這裏咱們首先回憶一下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之禪中提到過：命名空間是一種絕妙的理念，讓咱們盡情的使用發揮吧！

命名空間一共分爲三種：

　　全局命名空間

　　局部命名空間

　　內置命名空間

*內置命名空間中存放了python解釋器爲咱們提供的名字：input,print,str,list,tuple...它們都是咱們熟悉的，拿過來就能夠用的方法。

三種命名空間之間的加載與取值順序：

加載順序：內置命名空間(程序運行前加載)->全局命名空間(程序運行中：從上到下加載)->局部命名空間(程序運行中：調用時才加載)

命名空間的取值：

　　在局部調用：局部命名空間->全局命名空間->內置命名空間

x = 1
def f(x): print(x) print(10)

　　在全局調用：全局命名空間->內置命名空間

x = 1
def f(x): print(x) f(10) print(x)



# 在全局引用max

print(max)

做用域

做用域就是做用範圍，按照生效範圍能夠分爲全局做用域和局部做用域。

全局做用域：包含內置名稱空間、全局名稱空間，在整個文件的任意位置都能被引用、全局有效

局部做用域：局部名稱空間，只能在局部範圍內生效

globals和locals方法

# 在全局調用

print(globals()) print(locals())


# 在局部調用
def func(): a = 12 b = 20 print(locals()) print(globals()) func()

global關鍵字

a = 10
def func(): global a a = 20 print(a) func() print(a)

函數的嵌套和做用域鏈

函數的嵌套調用

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(): print(a) 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()

nonlocal關鍵字

# 1.外部必須有這個變量
# 2.在內部函數聲明nonlocal變量以前不能再出現同名變量
# 3.內部修改這個變量若是想在外部有這個變量的第一層函數中生效

def f1():

 a = 1 def f2(): nonlocal a 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.能夠看成函數的參數和返回值

*不明白？那就記住一句話，就當普通變量用

第一類對象（first-class object）指 1.可在運行期建立 2.可用做函數參數或返回值 3.可存入變量的實體。

閉包

def func(): name = 'eva' 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()

# 閉包獲取網絡應用
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)

本章小結

命名空間：

　　一共有三種命名空間從大範圍到小範圍的順序：內置命名空間、全局命名空間、局部命名空間

做用域（包括函數的做用域鏈）：

小範圍的能夠用大範圍的
可是大範圍的不能用小範圍的
範圍從大到小（圖）

在小範圍內，若是要用一個變量，是當前這個小範圍有的，就用本身的
若是在小範圍內沒有，就用上一級的，上一級沒有就用上上一級的，以此類推。
若是都沒有，報錯

函數的嵌套：

　　嵌套調用

　　嵌套定義：定義在內部的函數沒法直接在全局被調用

函數名的本質：

　　就是一個變量，保存了函數所在的內存地址

閉包：

　　內部函數包含對外部做用域而非全劇做用域名字的引用，該內部函數稱爲閉包函數