Python3 裝飾器
阿新 • • 發佈：2019-02-15
寫程式碼要遵循開放封閉原則，雖然在這個原則是用的面向物件開發，但是也適用於函數語言程式設計，簡單來說，它規定已經實現的功能程式碼不允許被修改，但可以被擴充套件，即：
- 封閉：已實現的功能程式碼塊
- 開放：對擴充套件開發
如果將開放封閉原則應用在上述需求中，那麼就不允許在函式 f1 、f2、f3、f4的內部進行修改程式碼，老闆就給了Low BBB一個實現方案：
def w1(func):
def inner():
# 驗證1
# 驗證2
# 驗證3
func()
return inner
@w1
def f1():
print('f1' 對於上述程式碼，也是僅僅對基礎平臺的程式碼進行修改，就可以實現在其他人呼叫函式 f1 f2 f3 f4 之前都進行【驗證】操作，並且其他業務部門無需做任何操作。
單獨以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 等於 f1return 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 "<b>" + fn() + "</b>"
return wrapped
#定義函式：完成包裹資料
def makeItalic(fn):
def wrapped():
return "<i>" + fn() + "</i>"
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()))
執行結果:
<b>hello world-1</b>
<i>hello world-2</i>
<b><i>hello world-3</i></b>
4. 裝飾器(decorator)功能
- 引入日誌
- 函式執行時間統計
- 執行函式前預備處理
- 執行函式後清理功能
- 許可權校驗等場景
- 快取
5. 裝飾器示例
例1:無引數的函式
from time import ctime, sleep
def timefun(func):
def wrappedfunc():
print("%s called at %s"%(func.__name__, ctime()))
func()
return wrappedfunc
@timefun
def foo():
print("I am foo")
foo()
sleep(2)
foo()
上面程式碼理解裝飾器執行行為可理解成
foo = timefun(foo)
#foo先作為引數賦值給func後,foo接收指向timefun返回的wrappedfunc
foo()
#呼叫foo(),即等價呼叫wrappedfunc()
#內部函式wrappedfunc被引用，所以外部函式的func變數(自由變數)並沒有釋放
#func裡儲存的是原foo函式物件
例2:被裝飾的函式有引數
from time import ctime, sleep
def timefun(func):
def wrappedfunc(a, b):
print("%s called at %s"%(func.__name__, ctime()))
print(a, b)
func(a, b)
return wrappedfunc
@timefun
def foo(a, b):
print(a+b)
foo(3,5)
sleep(2)
foo(2,4)
例3:被裝飾的函式有不定長引數
from time import ctime, sleep
def timefun(func):
def wrappedfunc(*args, **kwargs):
print("%s called at %s"%(func.__name__, ctime()))
func(*args, **kwargs)
return wrappedfunc
@timefun
def foo(a, b, c):
print(a+b+c)
foo(3,5,7)
sleep(2)
foo(2,4,9)
例4:裝飾器中的return
from time import ctime, sleep
def timefun(func):
def wrappedfunc():
print("%s called at %s"%(func.__name__, ctime()))
func()
return wrappedfunc
@timefun
def foo():
print("I am foo")
@timefun
def getInfo():
return '----hahah---'
foo()
sleep(2)
foo()
print(getInfo())
執行結果:
foo called at Fri Nov 4 21:55:35 2016
I am foo
foo called at Fri Nov 4 21:55:37 2016
I am foo
getInfo called at Fri Nov 4 21:55:37 2016
None
如果修改裝飾器為return func()，則執行結果：
foo called at Fri Nov 4 21:55:57 2016
I am foo
foo called at Fri Nov 4 21:55:59 2016
I am foo
getInfo called at Fri Nov 4 21:55:59 2016
----hahah---
總結：
- 一般情況下為了讓裝飾器更通用，可以有return
例5:裝飾器帶引數,在原有裝飾器的基礎上，設定外部變數
#decorator2.py
from time import ctime, sleep
def timefun_arg(pre="hello"):
def timefun(func):
def wrappedfunc():
print("%s called at %s %s"%(func.__name__, ctime(), pre))
return func()
return wrappedfunc
return timefun
@timefun_arg("itcast")
def foo():
print("I am foo")
@timefun_arg("python")
def too():
print("I am too")
foo()
sleep(2)
foo()
too()
sleep(2)
too()
可以理解為
foo()==timefun_arg("itcast")(foo)()
例6：類裝飾器（擴充套件，非重點）
裝飾器函式其實是這樣一個介面約束，它必須接受一個callable物件作為引數，然後返回一個callable物件。在Python中一般callable物件都是函式，但也有例外。只要某個物件重寫了 __call__() 方法，那麼這個物件就是callable的。
class Test():
def __call__(self):
print('call me!')
t = Test()
t() # call me
類裝飾器demo
class Test(object):
def __init__(self, func):
print("---初始化---")
print("func name is %s"%func.__name__)
self.__func = func
def __call__(self):
print("---裝飾器中的功能---")
self.__func()
#說明：
#1. 當用Test來裝作裝飾器對test函式進行裝飾的時候，首先會建立Test的例項物件
# 並且會把test這個函式名當做引數傳遞到__init__方法中
# 即在__init__方法中的func變數指向了test函式體
#
#2. test函式相當於指向了用Test創建出來的例項物件
#
#3. 當在使用test()進行呼叫時，就相當於讓這個物件()，因此會呼叫這個物件的__call__方法
#
#4. 為了能夠在__call__方法中呼叫原來test指向的函式體，所以在__init__方法中就需要一個例項屬性來儲存這個函式體的引用
# 所以才有了self.__func = func這句程式碼，從而在呼叫__call__方法中能夠呼叫到test之前的函式體
@Test
def test():
print("----test---")
test()
showpy()#如果把這句話註釋，重新執行程式，依然會看到"--初始化--"
執行結果如下：
---初始化---
func name is test
---裝飾器中的功能---
----test---