網上很多講解單個python 裝飾器的文章,基礎知識我們簡單描述。

首先了解裝飾器是用來干什麼的,裝飾器可以增加函數的功能,可以通過函數實現,可以通過類實現,分別介紹兩種的簡單例子。

裝飾者模式(Decorator Pattern),是在不必改變原類文件和使用繼承的情況下,動態的擴展一個對象的功能。它是通過創建一個包裝對象,也就是裝飾來包裹真實的對象。

適用裝飾者模式場合:
1.當我們需要為某個現有的對象,動態的增加一個新的功能或職責時,可以考慮使用裝飾模式。
2.當某個對象的職責經常發生變化或者經常需要動態的增加職責,避免為了適應這樣的變化,而增加繼承子類擴展的方式,因為這種方式會造成子類膨脹的速度過快,難以控制。

函數的單個裝飾器

使用內嵌包裝函數來確保每次新函數都被調用,內嵌包裝函數的形參和返回值與原函數相同,裝飾函數返回內嵌包裝函數對象。

def deco(func):
    def _deco():
        print("before myfunc() called.")
        func()
        print("  after myfunc() called.")
         #不需要返回func,實際上應返回原函數的返回值
    return _deco

@deco
def myfunc():
    print(" myfunc() called.")
    return 'ok'


myfunc()
myfunc()

打印結果為:

before myfunc() called.
myfunc() called.
after myfunc() called.
before myfunc() called.
myfunc() called.
after myfunc() called.

裝飾器帶類參數

裝飾器帶類參數:

class locker:
    def __init__(self):
        print("locker.__init__() should be not called.")

    @staticmethod
    def acquire():
        print("locker.acquire() called.(這是靜態方法)")

    @staticmethod
    def release():
        print("  locker.release() called.(不需要對象實例)")


def deco(cls):
    '''cls 必須實現acquire和release靜態方法'''

    def _deco(func):
        def __deco():
            print("before %s called [%s]." % (func.__name__, cls))
            cls.acquire()
            try:
                return func()
            finally:
                cls.release()
        return __deco
    return _deco

@deco(locker)
def myfunc():
    print(" myfunc() called.")

myfunc()
myfunc()

輸出結果為:

before myfunc called [<class ‘__main__.locker’>].
locker.acquire() called.(這是靜態方法)
myfunc() called.
locker.release() called.(不需要對象實例)
before myfunc called [<class ‘__main__.locker’>].
locker.acquire() called.(這是靜態方法)
myfunc() called.
locker.release() called.(不需要對象實例)

對一個函數應用多個裝飾器

def decorator_b(func):
    print ('Get in decorator_b')
    def inner_b(*args, **kwargs):
        print("b %s called." % func.__name__)
        print ('Get in inner_b')
        return func(*args, **kwargs)
    return inner_b

def decorator_a(func):
    print ('Get in decorator_a')
    def inner_a(*args, **kwargs):
        print("a %s called." % func.__name__)
        print ('Get in inner_a')
        return func(*args, **kwargs)
    return inner_a


@decorator_b
@decorator_a
def f(x):
    print ('Get in f')
    return x * 2

f(1)

輸出結果:

Get in decorator_a
Get in decorator_b
b inner_a called.
Get in inner_b
a f called.
Get in inner_a
Get in f

運行順序:
根據自下而上的原則來判斷地話,先執行 decorator_a 再執行 decorator_b , 那麼會先輸出 Get in decotator_a,Get in decorator_b;

上述裝飾器實際等價於:

f =decorator_b(decorator_a(f))(1)

decorator_a 函數來說,它返回的是個函數對象 inner_a ,這個函數對象是它內部定義的,所以decorator_b執行的是decorator_b(inner_a),那麼就可以理解為何打印出來“ b inner_a called.”;

在decorator_b中的 return func(args, *kwargs) 為inner_a(f),所以再執行decorator_a 中的inner_a(f),打印出“a f called.”;

最後執行f(1)。

類中對一個函數應用多個裝飾器

mylocker.py

class mylocker:
    def __init__(self):
        print("mylocker.__init__() called.")

    @staticmethod
    def acquire():
        print("mylocker.acquire() called.")

    @staticmethod
    def unlock():
        print("  mylocker.unlock() called.")


class lockerex(mylocker):
    @staticmethod
    def acquire():
        print("lockerex.acquire() called.")

    @staticmethod
    def unlock():
        print("  lockerex.unlock() called.")


def lockhelper(cls):
    '''cls 必須實現acquire和release靜態方法'''

    def _deco(func):
        print("%s %s called." % (func.__name__,cls))
        def __deco(*args, **kwargs):
            print("before %s called." % func.__name__)
            cls.acquire()
            try:
                return func(*args, **kwargs)
            finally:
                cls.unlock()

        return __deco

    return _deco

test.py

from mylocker import *


class example:
    @lockhelper(mylocker)
    def myfunc(self):
        print(" myfunc() called.")

    @lockhelper(mylocker)
    @lockhelper(lockerex)
    def myfunc2(self, a, b):
        print(" myfunc2() called.")
        return a + b


if __name__ == "__main__":
    a = example()
    #實例化過程:
    # 第一步lockhelper(mylocker)(myfunc) 打印 myfunc <class '__main__.lockerex'> called. 返回方法__deco,
    # 第二步lockhelper(lockerex)(myfunc2) 打印 myfunc2 <class '__main__.lockerex'> called. 返回方法__deco,
    # 第三步lockhelper(mylocker)(__deco) __deco <class '__main__.mylocker'> called. 返回方法__deco。

    a.myfunc()
    print(a.myfunc())
    print(a.myfunc2(1, 2))
    #過程解析:
    #等價於lockhelper(mylocker)(lockhelper(lockerex)(myfunc2))(1,2)
    #第一步 等價於lockhelper(mylocker)(__deco)(1,2) 因為lockerex(myfunc2)返回的是__deco方法
    #lockhelper(mylocker)(lockhelper(lockerex)(myfunc2))(1,2) 執行后打印 before __deco called.
    #傳入類為mylocker,執行cls.acquire() 打印 mylocker.acquire() called.
    #func(*args, **kwargs) 中func為lockhelper(lockerex)(myfunc2)
    #執行lockhelper(lockerex)(myfunc2) 打印 before myfunc2 called.
    #傳入類為lockerex,執行cls.acquire() 打印 lockerex.acquire() called.
    #傳入func(*args, **kwargs) 中func為myfunc2(1,2)
    #執行myfunc2(1,2) 打印 myfunc2() called. 返回 3
    #返回 3 執行lockerex的 cls.unlock() 打印 lockerex.unlock() called.
    #返回 3 執行mylocker的 cls.unlock() 打印 mylocker.unlock() called.

    print(a.myfunc2(3, 4))