裝飾器(Decorators)是 Python 的一個重要部分。簡單地說:他們是修改其他函數的功能的函數。他們有助於讓我們的代碼更簡短,也更Pythonic(Python範兒)。在程序開發中經常使用到的功能，合理使用裝飾器，能讓我們的程序如虎添翼。
1. 函數名應用
函數名是什麼？函數名是函數的名字，本質：變量，特殊的變量。
1 ） 函數名就是函數的內存地址，直接打印函數名，就是打印內存地址
def func1(): print(123) print(func1) #
2 ） 函數名可以作為變量
def func1(): print(111) f = func1 f() # f() 就是func1()
3 ） 函數名可以作為函數的參數
def func1(): print(111) def func2(x): x() func2(func1) #func1作為func2的參數
4 ） 函數名可以作為函數的返回值
def wrapper():
def inner():
print('inner')
return inner
f = wrapper()
f()
5 ）
函數名可以作為容器類類型的元素使用for循環批量執行函數
def func1():
print('func1')
def func2():
print('func2')
def func3():
print('func3')
l1 = [func1,func2,func3]
for i in l1:
i()
像上面函數名這種，叫做第一類對象。
第一類對象( first-class object)指：
1.可在運行期創建
2.可用作函數參數或返回值
3.可存入變量的實體
*不明白？那就記住一句話，就當普通變量用
2. 閉包
1、 閉包函數 ： 內部函數包含對外部作用域而非全局作用域變量的引用，該內部函數稱為閉包函數
2、閉包的作用：爬蟲、裝飾器
當程序執行遇到函數執行時，會在內存空間開闢局部命名空間，當函數執行完畢，該命名空間會被銷燬。但是如果這個函數內部形成閉包，則該內存空間不會隨著函數執行完而消失。
3、如何判斷是否是閉包：print(函數名.__closure__) 結果是 cell 說明是閉包，結果是 None 說明不是閉包。
閉包舉例
def wrapper(): name = 'summer' def inner(): print(name) inner() wrapper() # summer
如何判斷它是否是一個閉包函數呢？ 內層函數名.__closure__ cell 就是=閉包
例 1.
def wrapper(): name = 'summer' def inner(): print(name) inner() print(inner.__closure__) wrapper() 執行輸出： summer (,)
例 2.
name = 'summer' def wrapper(): def inner(): print(name) inner() print(inner.__closure__) wrapper() 結果輸出： summer None
返回值為None 表示它不是閉包，因為name是一個全局變量，如果函數調用了外層變量而非全局變量，那麼它就是閉包。
例 3.
name = 'summer' def wrapper2(): name1 = 'spring' def inner(): print(name) print(name1) inner() print(inner.__closure__) wrapper2() 結果輸出： summer spring (,)
只要引用了外層變量至少一次，非全局的，它就是閉包
例 4：判斷 下面的函數，是一個閉包嗎？ ******
name = 'summer' def wraaper2(n): #相當於n = 'summer' def inner(): print(n) inner() print(inner.__closure__) wraaper2(name) 結果輸出： summer (,)
它也是一個閉包. 雖然wraaper2傳了一個全局變量，但是在函數wraaper2內部，inner引用了外層變量，相當於在函數inner外層定義了 n = 'summer'，所以inner是一個閉包函數
閉包的好處 ： 當函數開始執行時，如果遇到了閉包，他有一個機制，他會永遠開闢一個內存空間，將閉包中的變量等值放入其中，不會隨著函數的執行完畢而消失。
舉一個例子：爬3次，內存開了3次，很佔用內存
from urllib.request import urlopen content1 = urlopen('https://www.cnblogs.com/').read().decode('utf-8') content2 = urlopen('https://www.cnblogs.com/').read().decode('utf-8') content3 = urlopen('https://www.cnblogs.com/').read().decode('utf-8')
把它封裝成閉包
from urllib.request import urlopen def index(): url = "https://www.cnblogs.com/" def get(): return urlopen(url).read() return get #return的是get，就是一個函數名 cnblog = index() print(cnblog) # .get at 0x02F46978> content = cnblog() print(content) # 頁面源碼
這個例子，只有第一遍，是從網站抓取的。之後的執行，直接從內存中加載，節省內存空間
3.裝飾器
3.1 裝飾器初識
裝飾器本質： 就是一個python函數，他可以讓其他函數在不需要做任何代碼變動的前提下，增加額外的功能，裝飾器的返回值也是一個函數對象。
裝飾器的應用場景：比如插入日誌，性能測試，事務處理，緩存等等場景。
import time
def timmer(f):
def inner():
start_time = time.time()
f()
end_time = time.time()
print('此函數的執行時間為{}'.format(end_time - start_time))
return inner
def func1():
print('in func1')
time.sleep(1)
func1 = timmer(func1)
print(func1)
func1() # 這裡的func1是全新的func1，就是上面的賦值，此時相當於執行 inner函數
輸出結果：
.inner at 0x03822DF8>
in func1
此函數的執行時間為1.0003533363342285
代碼從上至下執行
語法糖： 想測試誰，前面加@裝飾器函數，即可。 寫裝飾器，約定俗成，函數名為wrapper
def wrapper(func):
def inner(*args,**kwargs):
'''被裝飾函數之前'''
ret = func(*args,**kwargs)
'''被裝飾函數之後'''
return ret
return inner
@wrapper
def func(*args,**kwargs):
print(args,kwargs)
return 666
print(func())
輸出結果：
() {}
666
裝飾器利用return製造了一個假象，func()執行，其實是執行inner() ， func()把原來的func()給覆蓋了
3.2 裝飾器傳參
例 1： 上面裝飾器的例子，func1，要傳2個參數a,b
import time
def timmer(f):
def inner(a,b):
start_time = time.time()
f(a,b)
end_time = time.time()
print('此函數的執行時間為{}'.format(end_time - start_time))
return inner
@timmer
def func1(a,b):
print('in func1 {}{}'.format(a,b))
time.sleep(1) # 模擬程序邏輯
func1(1,2)
執行輸出：
in func1 12
此函數的執行時間為1.0006024837493896
例 2： 如果有多個參數呢？改成動態參數
import time
def timmer(f):
def inner(*args,**kwargs):
start_time = time.time()
f(*args,**kwargs)
end_time = time.time()
print('此函數的執行時間為{}'.format(end_time - start_time))
return inner
@timmer
def func1(*args,**kwargs):
print('in func1 {}{}'.format(args,kwargs))
time.sleep(1) # 模擬程序邏輯
func1(1,2,a='3',b=4)
執行輸出：
in func1 (1, 2){'b': 4, 'a': '3'}
此函數的執行時間為1.000101089477539
函數的執行時，*打散 ;
函數的定義時，*聚合。
from functools import wraps def wrapper(f): # f = func1 def inner(*args,**kwargs): #聚合，args （1,2,3） '''執行函數之前的相關操作''' ret = f(*args,**kwargs) # 打散 1,2,3 '''執行函數之後的相關操作''' return ret return inner @wrapper # func1 = wrapper(func1) func1 = inner def func1(*args): #args (1,2,3) 聚合 print(666) return args print(func1(*[1,2,3])) 執行輸出： 666 (1, 2, 3)
例 3 *****
import time #1.加載模塊
def timmer(*args,**kwargs): #2.加載變量 5.接收參數True,2,3
def wrapper(f): #6.加載變量 8.f = func1
print(args, kwargs) #9.接收timmer函數的值True,2,3
def inner(*args,**kwargs): #10.加載變量. 13.執行函數inner
if flag: #14 flag = True
start_time = time.time() #15 獲取當前時間
ret = f(*args,**kwargs) #16 執行func1
time.sleep(0.3) #19 等待0.3秒
end_time = time.time() #20 獲取當前時間
print('此函數的執行效率%f' % (end_time-start_time)) #21 打印差值
else:
ret = f(*args, **kwargs)
return ret #22 返回給函數調用者func1()
return inner #11 返回給函數調用者wrapper
return wrapper #7.返回給函數調用timmer(flag,2,3)
flag = True #3 加載變量
@timmer(flag,2,3) # 4.執行函數timmer(flag,2,3) 17.執行函數func1 兩步：1，timmer(flag,2,3) 相當於執行wrapper 2.@wrapper 裝飾器 func1 = wrapper(func1)
def func1(*args,**kwargs):
return 666 #18 返回給函數調用者f(*args,**kwargs)
print(func1()) #12 執行函數
寫裝飾器，一般嵌套3層就可以了
3.3 多個裝飾器，裝飾一個函數
def wrapper1(func): # func == f函數名
def inner1():
print('wrapper1 ,before func') # 2
func()
print('wrapper1 ,after func') # 4
return inner1
def wrapper2(func): # func == inner1
def inner2():
print('wrapper2 ,before func') # 1
func()
print('wrapper2 ,after func') # 5
return inner2
@wrapper2 # f = wrapper2(f) 裡面的f==inner1 外面的f == inner2
@wrapper1 # f = wrapper1(f) 裡面的f==函數名f 外面的f == inner1
def f(): # 3
print('in f')
f() # inner2()
執行輸出：
wrapper2 ,before func
wrapper1 ,before func
in f
wrapper1 ,after func
wrapper2 ,after func
哪個離函數近，哪個先計算 。 最底下的先執行
執行順序如下圖：
多個裝飾器，都是按照上圖的順序來的
4. 裝飾器的 __name__ 和 __doc___
__name__：函數名
__doc___：函數的解釋
普通函數
def func1(): """ 此函數是完成登陸的功能，參數分別是...作用。 return: 返回值是登陸成功與否（True，False） """ print(666) func1() print(func1.__name__) #獲取函數名 print(func1.__doc__) #獲取函數名註釋說明 執行輸出： 666 func1 此函數是完成登陸的功能，參數分別是...作用。 return: 返回值是登陸成功與否（True，False）
這個有什麼用呢？比如日誌功能，需要打印出誰在什麼時間，調用了什麼函數，函數是幹啥的，花費了多次時間，這個時候，就需要獲取函數的有用信息了
帶裝飾器的函數
def wrapper(f): # f = func1 def inner(*args,**kwargs): #聚合, args （1,2,3） '''執行函數之前的相關操作''' ret = f(*args,**kwargs) # 打散 1,2,3 '''執行函數之後的相關操作''' return ret return inner @wrapper def func1(): """ 此函數是完成登陸的功能，參數分別是...作用。 return: 返回值是登陸成功與否（True，False） """ print(666) return True func1() print(func1.__name__) print(func1.__doc__) 執行輸出： 666 inner 執行函數之前的相關操作
函數裝飾之後，相當於執行了inner函數，所以輸出inner
為了解決這個問題，需要 調用一個模塊wraps
wraps將 被修飾的函數(wrapped) 的一些屬性值賦值給修飾器函數(wrapper) ，最終讓屬性的顯示更符合我們的直覺
from functools import wraps def wrapper(f): # f = func1 @wraps(f) #f是被裝飾的函數 def inner(*args,**kwargs): #聚合args （1,2,3） '''執行函數之前的相關操作''' ret = f(*args,**kwargs) # 打散 1,2,3 '''執行函數之後的相關操作''' return ret return inner @wrapper def func1(): """ 此函數是完成登陸的功能，參數分別是...作用。 return: 返回值是登陸成功與否（True，False） """ print(666) return True func1() print(func1.__name__) print(func1.__doc__) 執行輸出： 666 func1 此函數是完成登陸的功能，參數分別是...作用。 return: 返回值是登陸成功與否（True，False）
歡迎大家關注我的頭條號，私信“python"，學習資料包免費分享給需要的朋友，另有python學習交流群，可以交流學習拓展人脈。
