python装饰器详解

        python中的装饰器(decorator)一般采用语法糖的形式，是一种语法格式。比如：@classmethod，@staticmethod，@property，@xxx.setter，@wraps()，@func_name等都是python中的装饰器。

        装饰器，装饰的对象是函数或者方法。各种装饰器的作用都是一样的：改变被装饰函数或者方法的功能，性质。

        下面主要讲解@wraps()，@func_name，类装饰器这两种装饰器。

目录

一，装饰器的官方定义

二，给某个函数加上一个装饰器

1，一般写法

2，标准的语法糖写法

二，给某个函数加上多个装饰器

2.1 给一个函数添加两个装饰器

2.2 当一个函数具有两个装饰器时的执行顺序

三，带参数装饰器的典型写法

四，@wraps()语法糖(了解)

五，类装饰器

1，不带参数的类装饰器

2，带参数的类装饰器

---

一，装饰器的官方定义

        装饰器本质上是一个Python函数(其实就是闭包)，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。装饰器用于有以下场景，比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。

二，给某个函数加上一个装饰器

1，一般写法

1. # 为函数添加一个统计运行时长的功能
2. import time
4. def how_much_time(func):
5. def inner():
6. t_start = time.time()
7. func()
8. t_end = time.time()
9. print("一共花费了{0}秒时间".format(t_end - t_start, ))
10. return inner
11. # 将增加的新功能代码以及被装饰函数运行代码func()一同打包返回，返回的是一个内部函数，这个被返回的函数就是装饰器
13. def sleep_5s():
14. time.sleep(5)
15. print("%d秒结束了" % (5,))
17. def sleep_6s():
18. time.sleep(6)
19. print("%d秒结束了" % (6,))
21. sleep_5s = how_much_time(sleep_5s)
22. # 因为sleep_5s函数的功能就是睡5秒钟，虽然增加了统计运行时间的功能，但是他本身功能没变(还是睡5秒钟)，所以仍然用原来函数名接收增加功能了的自己
23. sleep_6s = how_much_time(sleep_6s)
25. t1 = threading.Thread(target=sleep_5s)
26. t2 = threading.Thread(target=sleep_6s)
27. t1.start()
28. t2.start()
29. # 5秒结束了
30. # 一共花费了5.014161109924316秒时间
31. # 6秒结束了
32. # 一共花费了6.011810302734375秒时间

2，标准的语法糖写法

1. # 为函数添加一个统计运行时长的功能
2. import time
3. import threading
5. def how_much_time(func):
6. def inner():
7. t_start = time.time()
8. func()
9. t_end = time.time()
10. print("一共花费了{0}秒时间".format(t_end - t_start, ))
12. return inner
15. @how_much_time
16. # @how_much_time等价于sleep_5s = how_much_time(sleep_5s)
17. def sleep_5s():
18. time.sleep(5)
19. print("%d秒结束了" % (5,))
21. @how_much_time
22. def sleep_6s():
23. time.sleep(6)
24. print("%d秒结束了" % (6,))
26. t1 = threading.Thread(target=sleep_5s)
27. t2 = threading.Thread(target=sleep_6s)
28. t1.start()
29. t2.start()

二，给某个函数加上多个装饰器

        在这里以添加两个装饰器为例。

2.1 给一个函数添加两个装饰器

1. # 为函数添加一个统计运行时长的功能以及日志记录功能
2. import time
3. import threading
5. def how_much_time(func):
6. print("how_much_time函数开始了")
7. def inner():
8. t_start = time.time()
9. func()
10. t_end = time.time()
11. print("一共花费了{0}秒时间".format(t_end - t_start, ))
12. return inner
14. def mylog(func):
15. print("mylog函数开始了")
16. def inner_1():
17. print("start")
18. func()
19. print("end")
20. return inner_1
22. @mylog
23. @how_much_time
24. # 等价于mylog(how_much_time(sleep_5s))
25. def sleep_5s():
26. time.sleep(5)
27. print("%d秒结束了" % (5,))
29. if __name__ == '__main__':
30. sleep_5s()
31. #how_much_time函数开始了
32. #mylog函数开始了
33. #start
34. #5秒结束了
35. #一共花费了5.012601613998413秒时间
36. #end

2.2 当一个函数具有两个装饰器时的执行顺序

三，带参数装饰器的典型写法

四，@wraps()语法糖(了解)

        因为装饰器实质是就是一个函数，是一个被修饰过函数，他与原来未被修饰的函数是两个不同的函数对象。

        所以，这个装饰器丢失了原来函数对象的一些属性，比如：__name__，__doc__等属性。使用wraps语法糖可以保留这些属性。

五，类装饰器

        类装饰器这个写法，主要思路就是返回一个增加了新功能的函数对象，只不过这个函数对象是一个类的实例对象。由于装饰器是可调用对象，所以必须在类里面实现__call__方法，这样由类生成的各种实例加上()就可以运行了。

1，不带参数的类装饰器

1. import time
4. class Decorator:
5. def __init__(self, func):
6. self.func = func
8. def defer_time(self):
9. time.sleep(5)
10. print("延时结束了")
12. def __call__(self, *args, **kwargs):
13. self.defer_time()
14. self.func()
17. @Decorator
18. def f1():
19. print("延时之后我才开始执行")
22. f1()

2，带参数的类装饰器

1. import time
3. class Decorator:
4. def __init__(self, func):
5. self.func = func
7. def defer_time(self,time_sec):
8. time.sleep(time_sec)
9. print(f"{time_sec}s延时结束了")
11. def __call__(self, time):
12. self.defer_time(time)
13. self.func()
15. @Decorator
16. def f1():
17. print("延时之后我才开始执行")
19. f1(5)