python?裝飾器(Decorators)原理說明及操作代碼
本文目的是由淺入深地介紹python裝飾器原理
裝飾器(Decorators)是 Python 的一個重要部分
其功能是，在不修改原函數(shù)(類)定義代碼的情況下，增加新的功能
為了理解和實(shí)現(xiàn)裝飾器，我們先引入2個核心操作：
1 必要的2個核心操作
1.1 核心操作1， 函數(shù)內(nèi)部可以定義函數(shù)
def hi(name='world'):
print(f"hello, {name}")
def howdoyoudo(name2=name):
print(f"how do you do? {name2}")
howdoyoudo()
howdoyoudo('world')
hi("ytt") # 但是新函數(shù)還是存在的。
hi("ycy") # 但是新函數(shù)還是存在的。
try:
howdoyoudo()
except:
print("function not found")
在這個例子中，函數(shù)hi的形參name，默認(rèn)為'world'
在函數(shù)內(nèi)部，又定義了另一個函數(shù) howdoyoudo，定義這個函數(shù)時，將形參name作為新函數(shù)的形參name2的默認(rèn)值。
因此，在函數(shù)內(nèi)部調(diào)用howdoyoudo()時，將以調(diào)用hi時的實(shí)參為默認(rèn)值，但也可以給howdoyoudo輸入其他參數(shù)。
上面的例子運(yùn)行后輸出結(jié)果為：
hello, ytt
how do you do? ytt
how do you do? world
hello, ycy
how do you do? ycy
how do you do?
worldfunction not found
這里新定義的howdoyoudo可以稱作一個“閉包”。不少關(guān)于裝飾器的blog都提到了這個概念，但其實(shí)沒必要給它取一個多專業(yè)的名字。我們知道閉包是函數(shù)內(nèi)的函數(shù)就可以了
1.2 核心操作2 函數(shù)可以作為對象被輸入輸出
1.2.1 核心操作2的前置條件，函數(shù)是對象
當(dāng)我們進(jìn)行 def 的時候，我們在做什么？
def hi():
print("hi")
return "world"
這時，hi函數(shù)，打印一個字符串，同時返回一個字符串。
但hi函數(shù)本身也是一個對象，一個可以執(zhí)行的對象。執(zhí)行的方式是hi()。
這里hi和hi()有本質(zhì)區(qū)別，
hi 代表了這個函數(shù)對象本身
hi() 則是運(yùn)行了函數(shù)，得到函數(shù)的返回值。
def hi(name='world'):
print(f"hello, {name}")
return name
msg = hi() # 運(yùn)行函數(shù)，返回字符串，因此msg是個字符串
print(msg)
hello = hi # 將函數(shù)本身賦值給hello，此時hello是另一個函數(shù)，即使刪除原函數(shù)hi，新函數(shù)hello也可以正常調(diào)用
del hi # 刪除原函數(shù)hi
try:
hi()
except:
print("func hi not found")
hello("ycy") # 但是新函數(shù)還是存在的。
作為對比，可以想象以下代碼
a = 'example' b = a del a
此時也是b存在，可以正常使用。
1.2.2函數(shù)作為輸入
我們定義2個函數(shù)，分別實(shí)現(xiàn)自加1， 自乘2，
再定義一個函數(shù)double_exec，內(nèi)容是將某個函數(shù)調(diào)用2次
在調(diào)用double_exec時，可以將函數(shù)作為輸入傳進(jìn)來
def func1(n):
return n+1
def func2(n):
return n*2
def double_exec(f,x):
return f(f(x))
rst = double_exec(func1, 5)
print(rst)
rst = double_exec(func2, 3)
print(rst)
輸出結(jié)果就是
7
27
1.2.3 函數(shù)作為輸出
同樣，也可以將函數(shù)作為輸出
def select_func(i):
def func1(n):
return n+1
def func2(n):
return n*2
func_list = [func1, func2]
return func_list[i]
func = select_func(0) # 第1個函數(shù)
print(func(5))
func = select_func(1) # 第2個函數(shù)
print(func(5))
輸出結(jié)果為
6
10
2 嘗試構(gòu)造裝飾器
有了以上兩個核心操作，我們可以嘗試構(gòu)造裝飾器了。
裝飾器的目的：在不修改原函數(shù)(類)定義代碼的情況下，增加新的功能
試想一下，現(xiàn)在有一個原函數(shù)
def original_function:
print("this is original function")
在不修改原函數(shù)定義代碼的情況下，如果想進(jìn)行函數(shù)內(nèi)容的添加，可以將這個函數(shù)作為一個整體，添加到這樣的包裹中：
def my_decorator(f):
def wrap_func():
print(f"before call {f.__name__}")
f()
print(f"after call {f.__name__}")
return wrap_func
new_function = my_decorator(original_function)
我們定義了一個my_decorator函數(shù)，這個函數(shù)進(jìn)行了一種操作：
對傳入的f，添加操作(運(yùn)行前后增加打印)，并把添加操作后的內(nèi)容連同運(yùn)行原函數(shù)的內(nèi)容，一起傳出
這個my_decorator，定義了一種增加前后打印內(nèi)容的行為
調(diào)用my_decorator時，對這個行為進(jìn)行了操作。
因此，new_function是一個在original_function上增加了前后打印行為的新函數(shù)
這個過程被可以被稱作裝飾。
| 例子中的對象 | 角色 | 說明 |
|---|---|---|
| wrap | 閉包函數(shù) | 重新定義了一種格式，這個格式可以任意的，是裝飾器的真正內(nèi)容 |
| my_decorator | 裝飾器 | 定義了按warp這種格式進(jìn)行操作的函數(shù) |
| f | 待裝飾函數(shù)(形參) | 在定義裝飾器時，待裝飾函數(shù)只是一個參數(shù) |
| original_function | 實(shí)際進(jìn)行裝飾的函數(shù) | 一個具體的需要裝飾的函數(shù) |
| new_function | 裝飾后的函數(shù) | 一個具體的裝飾完成的函數(shù) |
這里已經(jīng)可以發(fā)現(xiàn)，裝飾器本身對于被裝飾的函數(shù)是什么，是不需要考慮的。裝飾器本身只定義了一種裝飾行為，這個行為是通過裝飾器內(nèi)部的閉包函數(shù)()進(jìn)行定義的。
運(yùn)行裝飾前后的函數(shù)，可以清晰看到裝飾的效果
def original_function():
print("this is original function")
def my_decorator(f):
def wrap_func():
print(f"before calling {f.__name__}")
f()
print(f"after calling {f.__name__}")
return wrap_func
new_function = my_decorator(original_function)
original_function()
print("#########")
new_function()
3裝飾器定義的簡寫
我們復(fù)現(xiàn)一下實(shí)際要用裝飾器的情況，我們往往有一種裝飾器，想應(yīng)用于很多個函數(shù)，比如
def my_decorator(f):
def wrap_func():
print(f"before calling {f.__name__}")
f()
print(f"after calling {f.__name__}")
return wrap_func
def print1():
print("num=1")
def print2():
print("num=2")
def print3():
print("num=3")
此時，如果我們想給3個print函數(shù)都加上裝飾器，需要這么做
new_print1 = my_decorator(print1) new_print2 = my_decorator(print2) new_print3 = my_decorator(print3)
實(shí)際調(diào)用的時候，就需要調(diào)用添加裝飾器的函數(shù)名了
new_print1() new_print2() new_print3()
當(dāng)然，也可以賦值給原函數(shù)名
print1 = my_decorator(print1) print1 = my_decorator(print2) print3 = my_decorator(print3)
這樣至少不需要管理一系列裝飾前后的函數(shù)。
同時，在不需要進(jìn)行裝飾的時候，需要把
print1 = my_decorator(print1) print1 = my_decorator(print2) print3 = my_decorator(print3)
全部刪掉。
事實(shí)上，這樣并不方便，尤其對于更復(fù)雜的裝飾器來說
為此，python提供了一種簡寫方式
def my_decorator(f):
def wrap_func():
print(f"before calling {f.__name__}")
f()
print(f"after calling {f.__name__}")
return wrap_func
@my_decorator
def print1():
print("num=1")
這個定義print1函數(shù)前的@my_decorator，相當(dāng)于在定義完print1后，自動直接運(yùn)行了
print1 = my_decorator(print1)
一個新的麻煩及解決辦法
不論采用@my_decorator放在新函數(shù)前，還是顯示地重寫print1 = my_decorator(print1)，都會存在一個問題：
裝飾后的函數(shù)，名字改變了(其實(shí)不止名字，一系列的索引都改變了)
def print1():
print("num=1")
print(f"before decorate, function name: {print1.__name__}")
print1 = my_decorator(print1)
print(f"after decorate, function name: {print1.__name__}")
輸出結(jié)果為:
before decorate, function name: print1
after decorate, function name: wrap_func
這個現(xiàn)象的原因是，裝飾行為本身，是通過構(gòu)造了一個新的函數(shù)（例子中是wrap_func函數(shù)）來實(shí)現(xiàn)裝飾這個行為的，然后把這個修改后的函數(shù)賦給了原函數(shù)名。
這樣，會導(dǎo)致我們預(yù)期的被裝飾函數(shù)的一些系統(tǒng)變量（比如__name__）發(fā)生了變化。
對此，python提供了解決方案：
from functools import wraps # 導(dǎo)入一個系統(tǒng)工具
def my_decorator(f):
@wraps(f) # 在定義裝飾行為函數(shù)的時候，增加一個新的裝飾器
def wrap_func():
print(f"before calling {f.__name__}")
f()
print(f"after calling {f.__name__}")
return wrap_func
經(jīng)過這個行為后，被裝飾函數(shù)的系統(tǒng)變量問題被解決了
def print1():
print("num=1")
print(f"before decorate, function name: {print1.__name__}")
print1 = my_decorator(print1)
print(f"after decorate, function name: {print1.__name__}")
輸出結(jié)果為
before decorate, function name: print1
after decorate, function name: print1
當(dāng)然，如果你不需要使用一些系統(tǒng)變量，也可以不關(guān)注這個問題。
復(fù)雜一點(diǎn)的情況1 被裝飾函數(shù)有輸入輸出
剛才的例子都比較簡單，被裝飾的函數(shù)是沒有參數(shù)的。如果被裝飾的函數(shù)有參數(shù)，只需要在定義裝飾行為時（事實(shí)上，這個才更通用），增加(*args, **kwargs)描述即可
from functools import wraps
def my_decorator(f):
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了輸入?yún)?shù)
print(f"before calling {f.__name__}")
ret = f(*args, **kwargs) # 透傳了輸入?yún)?shù)，并記錄了輸出
print(f"after calling {f.__name__}") # line-after
return ret # 執(zhí)行 "line-after" 后，將f的輸出返回
return wrap_func
之前的描述中可以感受到，對于例子中的裝飾行為(前后加打印)，函數(shù)被裝飾后，本質(zhì)上是調(diào)用了新的裝飾函數(shù)wrap_func。
因此，如果原函數(shù)需要有輸入?yún)?shù)傳遞，只需要在wrap_func（或其他任意名字的裝飾函數(shù)）定義時，也增加參數(shù)輸入(*args, **kwargs)，并將這些參數(shù)，原封不動地傳給待裝飾函數(shù)f。
這種定義裝飾行為的方式更具有普遍性，忘記之前的定義方式吧
我們試一下
@my_decorator
def my_add(x, y):
return x + y
n = my_add(1, 3)
print(n)
輸出
before calling my_add
after calling my_add
4
這里需要注意的是，如果按照以下的方式定義裝飾器
from functools import wraps
def my_decorator(f):
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了輸入?yún)?shù)
print(f"before calling {f.__name__}")
return f(*args, **kwargs) # 透傳了輸入?yún)?shù)，并記錄了輸出
print(f"after calling {f.__name__}") # line-after
return wrap_func
那么以下語句將不會執(zhí)行
print(f"after calling {f.__name__}") # line-after
因?yàn)檠b飾后實(shí)際的函數(shù)wrap_func(雖然名字被改成了原函數(shù)，系統(tǒng)參數(shù)也改成了原函數(shù))，運(yùn)行到return f(*args, **kwargs) 的時候已經(jīng)結(jié)束了
復(fù)雜一點(diǎn)的情況2 裝飾器有輸入
因?yàn)檠b飾器my_decorator本身也是可以輸入的，因此，只需要在定義裝飾器時，增加參數(shù)，并在后續(xù)函數(shù)中使用就可以了，比如
from functools import wraps
def my_decorator(f, msg=""):
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了輸入?yún)?shù)
print(f"{msg}, before calling {f.__name__}")
return f(*args, **kwargs) # 透傳了輸入?yún)?shù)，并記錄了輸出
print(f"{msg}, after calling {f.__name__}") # line-after
return wrap_func
此時裝飾器已經(jīng)可以有輸入?yún)?shù)了
def my_add(x, y):
return x + y
my_add = my_decorator(my_add, 'yusheng')
n = my_add(1, 3)
print(n)
輸出
yusheng, before calling my_add
yusheng, after calling my_add
4
你可能發(fā)現(xiàn)，為什么不用簡寫版的方法了
@my_decorator(msg='yusheng')
def my_add(x, y):
return x + y
n = my_add(1, 3)
print(n)
因?yàn)橐陨洗a會報錯！！
究其原因，雖然
@my_decorator
def my_add(x, y):
return x + y
等價于
def my_add(x, y):
return x + y
my_add = my_decorator(my_add)
但是，
@my_decorator(msg='yusheng')
def my_add(x, y):
return x + y
并不等價于
def my_add(x, y):
return x + y
my_add = my_decorator(my_add, msg='yusheng')
這本身和@語法有關(guān)，使用@my_decorator時，是系統(tǒng)在應(yīng)用一個以單個函數(shù)作為參數(shù)的閉包函數(shù)。即，@是不能帶參數(shù)的。
但是你應(yīng)該發(fā)現(xiàn)了，之前的@wraps(f)不是帶參數(shù)了嗎？請仔細(xì)觀察以下代碼
def my_decorator_with_parma(msg='')
def my_decorator(f):
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了輸入?yún)?shù)
print(f"{msg}, before calling {f.__name__}")
return f(*args, **kwargs) # 透傳了輸入?yún)?shù)，并記錄了輸出
print(f"{msg}, after calling {f.__name__}") # line-after
return wrap_func
return my_decorator
通過一層嵌套，my_decorator_with_parma本質(zhì)上是返回了一個參數(shù)僅為一個函數(shù)的函數(shù)(my_decorator)，但因?yàn)閙y_decorator對my_decorator_with_parma來說是一個閉包，my_decorator_with_parma是可以帶參數(shù)的。（這句話真繞）
通過以上的定義，我們再來看
@my_decorator_with_parma(msg='yusheng')
def my_add(x, y):
return x + y
可以這么理解，my_decorator_with_parma(msg='yusheng')的結(jié)果是原來的my_decorator函數(shù)，同時，因?yàn)閙y_decorator_with_parma可以傳參，參數(shù)實(shí)際上是參與了my_decorator的（因?yàn)閙y_decorator對my_decorator_with_parma是閉包），my_decorator_with_parma(msg='yusheng')全等于一個有參數(shù)參加的my_decorator
因此，以上代碼等價于有參數(shù)msg傳遞的
@my_decorator
def my_add(x, y):
return x + y
比較繞，需要理解一下，或者干脆強(qiáng)記這種范式：
from functools import wraps
def my_decorator(msg=''): # 名字改一下
def inner_decorator(f): # 名字改一下
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了輸入?yún)?shù)
print(f"{msg}, before calling {f.__name__}")
ret = f(*args, **kwargs) # 透傳了輸入?yún)?shù)，并記錄了輸出
print(f"{msg}, after calling {f.__name__}") # line-after
return ret
return wrap_func
return inner_decorator
以上范式包含函數(shù)的輸入輸出、裝飾器的輸入，可以應(yīng)對大部分情況了。
實(shí)驗(yàn)一下：
@my_decorator(msg='yusheng')
def my_add(x, y):
return x + y
my_add(1, 2)
輸出
yusheng, before calling my_add
yusheng, after calling my_add
有用的函數(shù)裝飾器例子
from functools import wraps
import datetime
def log(output_path=None): # 名字改一下
def decorator(f): # 名字改一下
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了輸入?yún)?shù)
now = datetime.datetime.now()
msg = now.strftime("%Y-%m-%d %H:%M:%S") # 運(yùn)行時刻
msg += f" {f.__name__}()\n" # 運(yùn)行的函數(shù)名
ret = f(*args, **kwargs) # 透傳了輸入?yún)?shù)，并記錄了輸出
aft = datetime.datetime.now()
time_cost = aft - now
ms = time_cost.total_seconds() * 10**3 # 毫秒
msg += now.strftime("%Y-%m-%d %H:%M:%S")
msg += f" {f.__name__}() return, cost {ms} ms"
if output_path is None:
print(msg)
else:
print(f"print logs into {output_path}")
with open(output_path, 'a+') as fp:
fp.write(msg + '\n')
return wrap_func
return decorator
以上是一個log裝飾器，利用datetime統(tǒng)計了函數(shù)的耗時，
并且，裝飾器可以進(jìn)行輸出文件操作，如果給出了文件路徑，則輸出文件，否則就打印。
利用這個裝飾器，可以靈活地進(jìn)行耗時統(tǒng)計
@log()
def my_sum(x, y):
s = 0
for i in range(x, y+1):
s += i
return s
my_sum(1, 9999999)
不設(shè)置輸出文件地址，則打印。運(yùn)行結(jié)果為：
2021-12-03 10:01:52 my_sum()
2021-12-03 10:01:52 my_sum() return, cost 506.3299999999999 ms
也可以輸出到文件
@log('test.log')
def my_sum(x, y):
s = 0
for i in range(x, y+1):
s += i
return s
my_sum(1, 9999999)
輸出結(jié)果為
print logs into test.log
同時在當(dāng)前目錄生成了一個test.log 文件，內(nèi)容為：
2021-12-03 10:03:17 my_sum()
2021-12-03 10:03:17 my_sum() return, cost 461.813 ms
從裝飾函數(shù)到裝飾類
以上的裝飾器都是以函數(shù)形式出現(xiàn)的，但我們可以稍做改寫，將裝飾器以類的形式實(shí)現(xiàn)。
from functools import wraps
import datetime
class Log:
def __init__(self, path=None):
self._output = path
def __call__(self, f): # 相當(dāng)于原來的 inner_decorator
@wraps(f)
def wrap_func(*args, **kwargs): # 增加了輸入?yún)?shù)
now = datetime.datetime.now()
msg = now.strftime("%Y-%m-%d %H:%M:%S") # 運(yùn)行時刻
msg += f" {f.__name__}()\n" # 運(yùn)行的函數(shù)名
ret = f(*args, **kwargs) # 透傳了輸入?yún)?shù)，并記錄了輸出
aft = datetime.datetime.now()
time_cost = aft - now
ms = time_cost.total_seconds() * 10**3 # 毫秒
msg += now.strftime("%Y-%m-%d %H:%M:%S")
msg += f" {f.__name__}() return, cost {ms} ms"
if self._output is None:
print(msg)
else:
print(f"print logs into {self._output}")
with open(self._output, 'a+') as fp:
fp.write(msg + '\n')
return wrap_func
這個裝飾器類Log 上個例子里的裝飾器函數(shù)log功能是一樣的，同時，這個裝飾器類還可以作為基類被其他繼承，進(jìn)一步增加功能。
本文來自博客園，作者：坦先生的AI資料室，轉(zhuǎn)載請注明原文鏈接：https://www.cnblogs.com/yushengchn/p/15636944.html
到此這篇關(guān)于python 裝飾器(Decorators)原理說明的文章就介紹到這了,更多相關(guān)python 裝飾器Decorators內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要為大家介紹了Python中如何將文件中的內(nèi)容讀取出去來的方法，文中通過示例進(jìn)行了詳細(xì)講解，感興趣的小伙伴快跟隨小編一起學(xué)習(xí)一下2022-03-03
Python實(shí)現(xiàn)PDF轉(zhuǎn)換文本詳解
這篇文章主要介紹了詳解用Python把PDF轉(zhuǎn)換為文本方法總結(jié)，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-10-10
這篇文章主要介紹了python求眾數(shù)問題實(shí)例,包括文件的讀寫、字典的運(yùn)用及數(shù)值的計算等技巧,需要的朋友可以參考下2014-09-09
今天小編就為大家分享一篇使用python模擬高斯分布例子，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2019-12-12
python pandas實(shí)現(xiàn)excel轉(zhuǎn)為html格式的方法
今天小編就為大家分享一篇python pandas實(shí)現(xiàn)excel轉(zhuǎn)為html格式的方法，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2018-10-10
在本篇文章里小編給大家分享的是關(guān)于Python pandas用法以及相關(guān)實(shí)例代碼，需要的朋友們可以學(xué)習(xí)下。2019-08-08
Python中判斷輸入是否為數(shù)字的實(shí)現(xiàn)代碼
這篇文章主要介紹了Python中判斷輸入是否為數(shù)字的實(shí)現(xiàn)代碼,需要的朋友可以參考下2018-05-05
python實(shí)現(xiàn)socket客戶端和服務(wù)端簡單示例
