python3 裝飾器全解

本章結構:

1.理解裝飾器的前提准備

2.裝飾器:無參/帶參的被裝飾函數,無參/帶參的裝飾函數

3.裝飾器的缺點

4.python3的內置裝飾器

5.本文參考

 

理解裝飾器的前提:1.所有東西都是對象(函數可以當做對象傳遞) 2.閉包

閉包的概念:
1）函數嵌套
2）內部函數使用外部函數的變量
3）外部函數的返回值為內部函數

下面寫一個最為簡單的閉包的例子:

def test(name):
    def test_in():
        print(name)
    return test_in

func = test('whyz')
func()

裝飾器的原型:

import time
def showtime(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('spend is {}'.format(end_time - start_time))

    return wrapper

def foo():
    print('foo..')
    time.sleep(3)

foo = showtime(foo)
foo()

不帶參數的裝飾器:(裝飾器,被裝飾函數都不帶參數)

import time
def showtime(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('spend is {}'.format(end_time - start_time))

    return wrapper

@showtime  #foo = showtime(foo)
def foo():
    print('foo..')
    time.sleep(3)

@showtime #doo = showtime(doo)
def doo():
    print('doo..')
    time.sleep(2)

foo()
doo()

帶參數的被裝飾的函數

import time
def showtime(func):
    def wrapper(a, b):
        start_time = time.time()
        func(a,b)
        end_time = time.time()
        print('spend is {}'.format(end_time - start_time))

    return wrapper

@showtime #add = showtime(add)
def add(a, b):
    print(a+b)
    time.sleep(1)

@showtime #sub = showtime(sub)
def sub(a,b):
    print(a-b)
    time.sleep(1)

add(5,4)
sub(3,2)

帶參數的裝飾器(裝飾函數),

實際是對原有裝飾器的一個函數的封裝,並返回一個裝飾器(一個含有參數的閉包函數),
當使用@time_logger(3)調用的時候,Python能發現這一層封裝,並將參數傳遞到裝飾器的環境去

import time
def time_logger(flag = 0):
    def showtime(func):
        def wrapper(a, b):
            start_time = time.time()
            func(a,b)
            end_time = time.time()
            print('spend is {}'.format(end_time - start_time))
            
            if flag:
                print('將此操作保留至日志')

        return wrapper

    return showtime

@time_logger(2)  #得到閉包函數showtime,add = showtime(add)
def add(a, b):
    print(a+b)
    time.sleep(1)

add(3,4)

類裝飾器:一般依靠類內部的__call__方法

import time
class Foo(object):
    def __init__(self, func):
        self._func = func

    def __call__(self):
        start_time = time.time()
        self._func()
        end_time = time.time()
        print('spend is {}'.format(end_time - start_time))

@Foo  #bar = Foo(bar)
def bar():
    print('bar..')
    time.sleep(2)

bar()

使用裝飾器的缺點:

1.位置錯誤的代碼->不要在裝飾器之外添加邏輯功能
2.不能裝飾@staticmethod 或者 @classmethod已經裝飾過的方法
3.裝飾器會對原函數的元信息進行更改,比如函數的docstring,__name__,參數列表:

下面對裝飾器第第三個缺點進行剖析,

import time
def showtime(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('spend is {}'.format(end_time - start_time))

    return wrapper

@showtime  #foo = showtime(foo)
def foo():
    print('foo..')
    time.sleep(3)

def doo():
    print('doo..')
    time.sleep(2)

print(foo.__name__)
print(doo.__name__)

結果為:

wrapper
doo

由此可以看出,裝飾器會對原函數的元信息進行更改,可以使用wraps,進行原函數信息的添加

注解:wraps本身也是一個裝飾器,他能把函數的元信息拷貝到裝飾器函數中使得裝飾器函數與原函數有一樣的元信息

以下是一個wraps的例子:

import time
from functools import wraps
def showtime(func):

    @wraps(func)    
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('spend is {}'.format(end_time - start_time))

    return wrapper

@showtime  #foo = showtime(foo)
def foo():
    print('foo..')
    time.sleep(3)

def doo():
    print('doo..')
    time.sleep(2)

print(foo.__name__)
print(doo.__name__)

結果為:

foo
doo

常用的內置裝飾器:1.staticmethod: 類似實現了靜態方法 注入以后,可以直接 : 類名.方法

2.property:經過property裝飾過的函數 不再是一個函數,而是一個property,類似實現get,set方法

@property
def width(self):
return self.__width

@width.setter
def width(self, newWidth):
self.__width = newWidth

3.classmethod: 與staticmethod很相似,貌似就只有這一點區別:
第一個參數需要是表示自身類的 cls 參數，
可以來調用類的屬性，類的方法，實例化對象等。

 

 

本文參考:

1.https://www.cnblogs.com/vamei/archive/2013/02/16/2820212.html

2.https://www.cnblogs.com/wupeiqi/articles/4980620.html

3.https://www.cnblogs.com/yuanchenqi/articles/5830025.html

4.https://blog.csdn.net/mdzzname/article/details/78702440