裝飾器的完整實現及原理

1、簡單裝飾器

說明：代碼在下邊。裝飾前后，我們都打印一遍如下內容，做一下對比。

• print(foo)           # 打印當前函數對象
• print(foo.__name__)  # 打印foo函數的函數名
• print(foo.__doc__)   # 打印foo函數的文檔字符串(docString)

裝飾之前：

• <function foo at 0x000002569AAB5620>
• foo
• this is foo

裝飾之后：

• <function check_result.<locals>.wrapper at 0x00000250E11F56A8>
• wrapper
• this is wrapper

可以看出，foo的引用發生了變化。裝飾的過程是這樣的，python解釋器會將foo作為參數傳遞給check_result函數，func就引用了foo函數，並將返回值給了foo，因為返回值wrapper引用了wrapper函數，所以foo的引用就變為了wrapper函數。這時再去執行foo，就等於是在執行wrapper函數了。需要注意的是在裝飾之后，我我們的foo函數並沒有銷毀，而是被func引用着。不然執行的時候也不會有結果了。可是怎么查看呢？使用 print(foo.__closure__[0].cell_contents) 則會看到輸出 <function foo at 0x000001F2C7465620> 。這樣我就找到了最開始定義的foo函數了！

'''
簡單裝飾器:
    實現裝飾后函數的功能是如果x和y相乘為負數，則返回0
'''

def check_result(func):
    '''hahah'''
    def wrapper(*args, **kwargs):
        '''this is wrapper'''
        result = func(*args, **kwargs)

        if result < 0:
            return 0
        else:
            return result
    return wrapper


@check_result
def foo(x, y):
    '''this is foo'''
    return x * y




# 裝飾過程拆解
# wrapper = check_result(foo)
# foo = wrapper

2、多層裝飾器

說明：在理解簡單裝飾器的基礎上，再來看多層的裝飾器，會很好理解。只需要關注一下多層裝飾器的裝飾順序和執行順序即可。

'''
多層裝飾器
'''

def deco1(func):
    def wrapper1(*args, **kwargs):
        '''this is wrapper1'''
        print('start 1')
        result = func(*args, **kwargs)
        print('end   1')
        return result
    return wrapper1


def deco2(func):
    def wrapper2(*args, **kwargs):
        '''this is wrapper2'''
        print('start 2')
        result = func(*args, **kwargs)
        print('end   2')
        return result
    return wrapper2


def deco3(func):
    def wrapper3(*args, **kwargs):
        '''this is wrapper3'''
        print('start 3')
        result = func(*args, **kwargs)
        print('end   3')
        return result
    return wrapper3


@deco1
@deco2
@deco3
def foo(x, y):
    '''this is foo'''
    return x * y

print(foo(8, 9))
'''
輸出結果：
    start 1
    start 2
    start 3
    end   3
    end   2
    end   1
    72
'''


'''
裝飾的過程：
    wrapper3 = deco3(foo)
    wrapper2 = deco2(wrapper3)
    wrapper1 = deco1(wrapper2)
    foo = wrapper1


執行的過程：正好和裝飾的過程相反。
        foo(8, 9)--->wrapper1(8, 9)--->deco1(wrapper2)(8, 9)--->
                                                                |
                                                                v
        deco1( deco2( deco3(foo) ) )(8, 9)<---deco1( deco2(wrapper3) )(8, 9)
        類比穿衣服，穿(裝飾)的時候從里往外一層套一層，脫(執行)的時候從外到里一層一層脫。
'''

3、帶參裝飾器

說明：傳入函數執行的次數，統計執行完成的時間。

實現方法：使用工廠模式，定義一個工廠函數，它本身不是裝飾器，但是返回值是一個裝飾器，是用來"生產"裝飾器的。如下所示：

'''
帶參裝飾器
'''

import time

def timer(count):
    def deco(func):
        def wrapper(*args, **kwargs):
            '''this is wrapper'''
            t1 = time.time()
            for i in range(count):
                result = func(*args, **kwargs)
            t2 = time.time()
            print(t2 - t1)
            return result
        return wrapper
    return deco


@timer(10000000)      # 獲取foo執行10000000次的時間
def foo(x, y):
    '''this is foo'''
    return x * y

4、類裝飾器

說明：想要明白類裝飾器的原理，我們先要了解一下__call__這個方法。這個方法是python中所有能被調用的對象具有的內置方法，比如類，函數。調用類的過程就是得到一個類的實例的過程，如果要做類裝飾器我們得讓該類的實例可以被調用。裝飾器的本質也是一個函數被調用執行的過程。先看下面一段代碼：

class A:
    pass


def foo(x, y):
    return x, y


print(A.__call__)
print(foo.__call__)

print(foo.__call__(3, 5))   # 打印結果  15
print(foo(3, 5))            # 打印結果  15

打印結果為：可以看到，有__call__方法的才能被調用。還有一個方法判斷一個對象是否能被調用 callable() ，傳入對象，若返回True則表示能被調用，否則不能被調用。

 <method-wrapper '__call__' of type object at 0x000002CE9522BF48>

<method-wrapper '__call__' of function object at 0x000002CE953B1E18>

根據這個特性，我們設計我們的類裝飾器：

'''
類裝飾器
'''

class Deco:
    '''this is Deco'''
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        result = self.func(*args, **kwargs)
        if result < 0:
            return 0
        else:
            return result


@Deco                 # 裝飾后若結果為負數則返回0
def foo(x, y):
    '''this is foo'''
    return x * y

'''
裝飾過程如下：
    這個時候foo引用了Deco的一個實例，執行foo()也就是實例調用__call__方法的過程。
'''
foo = Deco(foo)