高階函數

在Python中，函數其實也是一種數據類型。

def test():

return 'hello world'

print(type(test)) #

函數對應的數據類型是 function,可以把它當做是一種復雜的數據類型。

既然同樣都是一種數據類型，我們就可以把它當做數字或者字符串來處理。

定義一個變量指向函數

在Python中，我們還可以定義一個變量，讓它來指向一個函數，相當于給函數起了一個別名。

def test():

return 'hello wrold'

fun = test # 定義了一個變量fun,讓它指向了 test 這個函數

print(fun()) # 使用fun()可以直接調用test這個函數

print(id(fun)) # 1819677672040

print(id(test)) # 1819677672040注意：在定義一個變量表示一個函數時，函數后面不能加括號！加括號表示的是調用這個函數。

def test():

return 'hello world'

result = test() # 這種寫法是調用test函數，并把函數的返回值賦值給result變量

print(result()) # 這里會報錯 TypeError: 'str' object is not callable

fun = test # 這種寫法是給test函數起了一個別名，注意，這里的test后面不能加()

fun() # 可以使用別名調用這個函數

高階函數

既然變量可以指向函數，函數的參數能接收變量，那么一個函數就可以接收另一個函數作為參數，同樣，我們還可以把一個函數當做另一個函數的返回值。這種函數的使用方式我們稱之為高階函數。

函數做為另一個函數的參數

def test(age,action):

if age < 18:

print('您還沒滿十八歲，請退出')

action() # 把參數action直接當做一個函數來調用

def smoke():

print('我已經年滿十八歲了，我想抽煙')

my_action = smoke # 定義一個變量my_action，讓它指向smoke函數

test(21, my_action) # 將my_action傳給 test 函數作為它的參數

test(21,smoke) # 還可以不再定義一個新的變量，直接傳入函數名

函數作為另一個函數的返回值

def test():

print('我是test函數里輸入的內容')

def demo():

print('我是demo里輸入的內容')

return test # test 函數作為demo函數的返回值

result = demo() # 我是demo里輸入的內容 調用 demo 函數，把demo函數的返回值賦值給 result

print(type(result)) # result 的類型是一個函數

result() # 我是demo里輸入的內容 我是test函數里輸入的內容 既然result是一個函數，那么就可以直接使用() 調用這個函數

demo()() # 我是demo里輸入的內容 我是test函數里輸入的內容

函數嵌套

在函數里面還可以定義函數，可以嵌套多層，執行需要被調用。

def outer():

print('outer----hello')

def inner(): # inner這個函數是在outer函數內部定義的

print('inner----hello')

inner() # inner函數只在outer函數內部可見

outer()

# inner() 這里會報錯，在outer函數外部無法訪問到inner函數

閉包

函數只是一段可執行代碼，編譯后就“固化”了，每個函數在內存中只有一份實例，得到函數的入口點便可以執行函數了。函數可以作為另一個函數的參數甚至返回值（高階函數）。函數還可以嵌套定義，即在一個函數內部可以定義另一個函數，有了嵌套函數這種結構，便會產生閉包問題。

什么是閉包

閉包是由函數及其相關的引用環境組合而成的實體(即：閉包=函數塊+引用環境)。

def outer(n):

num = n

def inner():

return num+1

return inner

print(outer(3)()) # 4

print(outer(5)()) # 5

在這段程序中，函數 inner 是函數 outer 的內嵌函數，并且 inner 函數是outer函數的返回值。我們注意到一個問題：內嵌函數 inner 中引用到外層函數中的局部變量num，Python解釋器會這么處理這個問題呢？ 先讓我們來看看這段代碼的運行結果，當我們調用分別由不同的參數調用 outer 函數得到的函數時，得到的結果是隔離的(相互不影響)，也就是說每次調用outer函數后都將生成并保存一個新的局部變量num,這里outer函數返回的就是閉包。 如果在一個內部函數里，對在外部作用域（但不是在全局作用域）的變量進行引用，那么內部函數就被認為是閉包(closure).

修改外部變量的值

閉包里默認不能修改外部變量。

def outer(n):

num = n

def inner():

num = num + 1

return num

return inner

print(outer(1)())

上述代碼運行時會報錯！

UnboundLocalError: local variable 'num' referenced before assignment

原因分析

在python里，只要看到了賦值語句，就會認為賦值語句的左邊是一個局部變量。num = num + 1 這段代碼里，num 在=的左邊，python解析器會認為我們要修改inner函數里num這個局部變量，而這個變量使用之前是未聲明的，所以會報錯。

解決方案

我們分析過，報錯的原因在于當我們在閉包內修改外部變量時，會被python解析器誤會為內部函數的局部變量。所以，解決方案就在于，我們需要想辦法，讓解析器知道我們不是要修改局部變量，而是要修改外部變量。解決方法一：使用列表解決

def outer(n):

num = [n] # 定義一個變量num,將 n 包裹到一個列表里

def inner():

num[0] = num[0] + 1 # 從列表里取出并修改數據

return num[0]

return inner

print(outer(1)())解決方法二：python3后使用 nonlocal 關鍵字

def outer(n):

num = n

def inner():

nonlocal num # 修改前使用nonlocal關鍵字對 num 變量進行說明

num = num + 1

return num

return inner

print(outer(2)())

裝飾器

裝飾器是程序開發中經常會用到的一個功能，用好了裝飾器，開發效率如虎添翼，所以這也是Python面試中必問的問題。但對于好多初次接觸這個知識的人來講，這個功能有點繞，自學時直接繞過去了，然后面試問到了就掛了，因為裝飾器是程序開發的基礎知識，這個都不會，別跟人家說你會Python, 看了下面的文章，保證你學會裝飾器。

1、先明白這段代碼

#### 第一波 ####

def foo():

print('foo')

foo # 表示是函數

foo() # 表示執行foo函數

#### 第二波 ####

def foo():

print('foo')

foo = lambda x: x + 1

foo() # 執行lambda表達式，而不再是原來的foo函數，因為foo這個名字被重新指向了另外一個匿名函數

函數名僅僅是個變量，只不過指向了定義的函數而已，所以才能通過 函數名()調用，如果 函數名=xxx被修改了，那么當在執行 函數名()時，調用的就不知之前的那個函數了

2、需求來了

初創公司有N個業務部門，基礎平臺部門負責提供底層的功能，如：數據庫操作、redis調用、監控API等功能。業務部門使用基礎功能時，只需調用基礎平臺提供的功能即可。如下：

############### 基礎平臺提供的功能如下 ###############

def f1():

print('f1')

def f2():

print('f2')

def f3():

print('f3')

def f4():

print('f4')

############### 業務部門A 調用基礎平臺提供的功能 ###############

f1()

f2()

f3()

f4()

############### 業務部門B 調用基礎平臺提供的功能 ###############

f1()

f2()

f3()

f4()

目前公司有條不紊的進行著，但是，以前基礎平臺的開發人員在寫代碼時候沒有關注驗證相關的問題，即：基礎平臺的提供的功能可以被任何人使用?，F在需要對基礎平臺的所有功能進行重構，為平臺提供的所有功能添加驗證機制，即：執行功能前，先進行驗證。

老大把工作交給 Low B，他是這么做的：跟每個業務部門交涉，每個業務部門自己寫代碼，調用基礎平臺的功能之前先驗證。誒，這樣一來基礎平臺就不需要做任何修改了。太棒了，有充足的時間泡妹子...

當天Low B 被開除了…

老大把工作交給 Low BB，他是這么做的：

############### 基礎平臺提供的功能如下 ###############

def f1():

# 驗證1

# 驗證2

# 驗證3

print('f1')

def f2():

# 驗證1

# 驗證2

# 驗證3

print('f2')

def f3():

# 驗證1

# 驗證2

# 驗證3

print('f3')

def f4():

# 驗證1

# 驗證2

# 驗證3

print('f4')

############### 業務部門不變 ###############

### 業務部門A 調用基礎平臺提供的功能###

f1()

f2()

f3()

f4()

### 業務部門B 調用基礎平臺提供的功能 ###

f1()

f2()

f3()

f4()

過了一周 Low BB 被開除了…

老大把工作交給 Low BBB，他是這么做的：只對基礎平臺的代碼進行重構，其他業務部門無需做任何修改

############### 基礎平臺提供的功能如下 ###############

def check_login():

# 驗證1

# 驗證2

# 驗證3

pass

def f1():

check_login()

print('f1')

def f2():

check_login()

print('f2')

def f3():

check_login()

print('f3')

def f4():

check_login()

print('f4')

老大看了下Low BBB 的實現，嘴角漏出了一絲的欣慰的笑，語重心長的跟Low BBB聊了個天：

老大說：

寫代碼要遵循開放封閉原則，雖然在這個原則是用的面向對象開發，但是也適用于函數式編程，簡單來說，它規定已經實現的功能代碼不允許被修改，但可以被擴展，即：封閉：已實現的功能代碼塊

開放：對擴展開發

如果將開放封閉原則應用在上述需求中，那么就不允許在函數 f1 、f2、f3、f4的內部進行修改代碼，老板就給了Low BBB一個實現方案：

def w1(func):

def inner():

# 驗證1

# 驗證2

# 驗證3

func()

return inner

@w1

def f1():

print('f1')

@w1

def f2():

print('f2')

@w1

def f3():

print('f3')

@w1

def f4():

print('f4')

對于上述代碼，也是僅僅對基礎平臺的代碼進行修改，就可以實現在其他人調用函數 f1 f2 f3 f4 之前都進行【驗證】操作，并且其他業務部門無需做任何操作。

Low BBB心驚膽戰的問了下，這段代碼的內部執行原理是什么呢？

老大正要生氣，突然Low BBB的手機掉到地上，恰巧屏保就是Low BBB的女友照片，老大一看一緊一抖，喜笑顏開，決定和Low BBB交個好朋友。

詳細的開始講解了：

單獨以f1為例：

def w1(func):

def inner():

# 驗證1

# 驗證2

# 驗證3

func()

return inner

@w1

def f1():

print('f1')

python解釋器就會從上到下解釋代碼，步驟如下：def w1(func): ==>將w1函數加載到內存

@w1

沒錯， 從表面上看解釋器僅僅會解釋這兩句代碼，因為函數在 沒有被調用之前其內部代碼不會被執行。

從表面上看解釋器著實會執行這兩句，但是 @w1 這一句代碼里卻有大文章， @函數名 是python的一種語法糖。

上例@w1內部會執行一下操作：

執行w1函數執行w1函數 ，并將 @w1 下面的函數作為w1函數的參數，即：@w1 等價于 w1(f1) 所以，內部就會去執行：

def inner():

#驗證 1

#驗證 2

#驗證 3

f1() # func是參數，此時 func 等于 f1

return inner# 返回的 inner，inner代表的是函數，非執行函數 ,其實就是將原來的 f1 函數塞進另外一個函數中

w1的返回值將執行完的w1函數返回值 賦值 給@w1下面的函數的函數名f1 即將w1的返回值再重新賦值給 f1，即：

新f1 = def inner():

#驗證 1

#驗證 2

#驗證 3

原來f1()

return inner所以，以后業務部門想要執行 f1 函數時，就會執行 新f1 函數，在新f1 函數內部先執行驗證，再執行原來的f1函數，然后將原來f1 函數的返回值返回給了業務調用者。

如此一來， 即執行了驗證的功能，又執行了原來f1函數的內容，并將原f1函數返回值 返回給業務調用者。Low BBB 你明白了嗎？要是沒明白的話，我晚上去你家幫你解決吧！！！

3. 再議裝飾器

# 定義函數：完成包裹數據

def makeBold(fn):

def wrapped():

return "" + fn() + ""

return wrapped

# 定義函數：完成包裹數據

def makeItalic(fn):

def wrapped():

return "" + fn() + ""

return wrapped

@makeBold

def test1():

return "hello world-1"

@makeItalic

def test2():

return "hello world-2"

@makeBold

@makeItalic

def test3():

return "hello world-3"

print(test1())

print(test2())

print(test3())

運行結果:

hello world-1

hello world-2

hello world-3

4. 裝飾器(decorator)功能引入日志

函數執行時間統計

執行函數前預備處理

執行函數后清理功能

權限校驗等場景

緩存

5. 裝飾器示例

例1:無參數的函數

def check_time(action):

def do_action():

action()

return do_action

@check_time

def go_to_bed():

print('去睡覺')

go_to_bed()

上面代碼理解裝飾器執行行為可理解成

result = check_time(go_to_bed) # 把go_to_bed 當做參數傳入給 check_time函數，再定義一個變量用來保存check_time的運行結果

result() # check_time 函數的返回值result是一個函數, result()再調用這個函數，讓它再調用go_to_bed函數

例2:被裝飾的函數有參數

def check_time(action):

def do_action(a,b):

action(a,b)

return do_action

@check_time

def go_to_bed(a,b):

print('{}去{}睡覺'.format(a,b))

go_to_bed("zhangsan","床上")

例3:被裝飾的函數有不定長參數

def test(cal):

def do_cal(*args,**kwargs):

cal(*args,**kwargs)

return do_cal

@test

def demo(*args):

sum = 0

for x in args:

sum +=x

print(sum)

demo(1, 2, 3, 4)

例4:裝飾器中的return

def test(cal):

def do_cal(*args,**kwargs):

return cal(*args,**kwargs) # 需要再這里寫return語句，表示調用函數，獲取函數的返回值并返回

return do_cal

@test

def demo(a,b):

return a + b

print(demo(1, 2)) #3

總結：一般情況下為了讓裝飾器更通用，可以有return

例5:裝飾器帶參數

def outer_check(time):

def check_time(action):

def do_action():

if time < 22:

return action()

else:

return '對不起，您不具有該權限'

return do_action

return check_time

@outer_check(23)

def play_game():

return '玩兒游戲'

print(play_game())

提高：使用裝飾器實現權限驗證

以下代碼不要求掌握，如果能看懂最好，如果能自己手動寫出來，那就太棒了！

def outer_check(base_permission):

def check_permission(action):

def do_action(my_permission):

if my_permission & base_permission:

return action(my_permission)

else:

return '對不起，您不具有該權限'

return do_action

return check_permission

READ_PERMISSION = 1

WRITE_PERMISSION = 2

EXECUTE_PERMISSION = 4

@outer_check(base_permission=READ_PERMISSION)

def read(my_permission):

return '讀取數據'

@outer_check(base_permission=WRITE_PERMISSION)

def write(my_permission):

return '寫入數據'

@outer_check(base_permission=EXECUTE_PERMISSION)

def execute(my_permission):

return '執行程序'

print(read(5))

函數應用：名片管理系統

# 定一個列表，用來存儲所有的名片信息(每個名片是一個字典)

info_list = []

def print_menu():

print("---------------------------")

print(" 名片管理系統 V1.0")

print(" 1:添加名片")

print(" 2:刪除名片")

print(" 3:修改名片")

print(" 4:查詢名片")

print(" 5:顯示所有名片")

print(" 6:退出系統")

print("---------------------------")

def add_new_info():

"""添加名片信息"""

new_name = input("請輸入姓名:")

new_tel = input("請輸入手機號:")

new_qq = input("請輸入QQ:")

for temp_info in info_list:

if temp_info['name'] == new_name:

print("此用戶名已經被占用,請重新輸入")

return # 如果一個函數只有return就相當于讓函數結束，沒有返回值

# 定義一個字典，用來存儲用戶的名片信息(這是一個字典)

info = {}

# 向字典中添加數據

info["name"] = new_name

info["tel"] = new_tel

info["qq"] = new_qq

# 向列表中添加這個字典

info_list.append(info)

def del_info():

"""刪除名片信息"""

del_num = int(input("請輸入要刪除的序號:"))

if 0 <= del_num < len(info_list):

del_flag = input("你確定要刪除么?yes or no")

if del_flag == "yes":

del info_list[del_num]

else:

print("輸入序號有誤,請重新輸入")

def modify_info():

"""修改名片信息"""

modify_num = int(input("請輸入要修改的序號:"))

if 0 <= modify_num < len(info_list):

print("你要修改的信息是:")

print("name:%s, tel:%s, QQ:%s" % (info_list[modify_num]['name'],

info_list[modify_num]['tel'],info_list[modify_num]['qq']))

info_list[modify_num]['name'] = input("請輸入新的姓名:")

info_list[modify_num]['tel'] = input("請輸入新的手機號:")

info_list[modify_num]['qq'] = input("請輸入新QQ:")

else:

print("輸入序號有誤,請重新輸入")

def search_info():

"""查詢名片信息"""

search_name = input("請輸入要查詢的名片姓名:")

for temp_info in info_list:

if temp_info['name'] == search_name:

print("查詢到的信息如下:")

print("name:%s, tel:%s, QQ:%s" % (temp_info['name'],

temp_info['tel'], temp_info['qq']))

break

else:

print("沒有您要找的信息....")

def print_all_info():

"""遍歷名片信息"""

print("序號\t姓名\t\t手機號\t\tQQ")

i = 0

for temp in info_list:

# temp是一個字典

print("%d\t%s\t\t%s\t\t%s" % (i, temp['name'], temp['tel'], temp['qq']))

i += 1

def main():

"""用來控制整個流程"""

while True:

# 1. 打印功能

print_menu()

# 2. 獲取用戶的選擇

num = input("請輸入要進行的操作(數字)")

# 3. 根據用戶選擇,做相應的事情

if num == "1":

# 添加名片

add_new_info()

elif num == "2":

# 刪除名片

del_info()

elif num == "3":

# 修改名片

modify_info()

elif num == "4":

# 查詢名片

search_info()

elif num == "5":

# 遍歷所有的信息

print_all_info()

elif num == "6":

# 退出系統

exit_flag = input("親,你確定要退出么?~~~~(>_<)~~~~(yes or no) ")

if exit_flag == "yes":

break

else:

print("輸入有誤,請重新輸入......")

# 程序的開始

main()

總結

以上是生活随笔為你收集整理的python高阶函数闭包装饰器_Python自学从入门到就业之高阶函数、嵌套函数、闭包、装饰器...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。