一、我们在python语言中

 常用@classmethod、@staticmethod这个装饰器，装饰器的作用简单来讲就是我们在很多地方可能都会用到一下相同的功能，这时我们会有两种想法。

  1. 1. 将这部分相同的功能封装成函数，然后在使用这个功能的时候程序中调用这个函数。
  2. 2.  将这部分相同的功能封装成装饰器，然后在使用这个功能的时候在需要处理的方法前加上对应的装饰器。

 

这两种方式各有好处，我认为
1中的方式更适合新加功能，通过单独新加函数实现功能，然后在需要的位置使用。
2中的方式更适合固定且经常使用的功能，比如说日志记录，执行时间计算等，只需要在需要用到该功能的时候直接在该方法前加装饰器即可。

二、装饰器

下面我们先看个例子：

  1. import time
  2. # Python学习交流群 815624229
  3. def origin_fun(a, b):
  4.     start_time = time.time()
  5.     s = a + b
  6.     exec_time = time.time() - start_time
  7.     print('执行时间： {}'.format(exec_time))
  8.     return s

 

以上是原函数，我们要得到传入两个参数的加和操作的时间消耗，我们如果需要对很多操作进行时间记录，有两个方法

  1. def func(a, b):
  2.     return a+b
  4. def get_begin_date():
  5.     return time.time()
  7. def final_func(a, b):
  8.     start_time = get_begin_date()
  9.     s = func(a, b)
  10.     exec_time = get_begin_date() - start_time
  11.     print('执行时间： {}'.format(exec_time))
  12.     return s

 

可以发现我们这样是可以实现的， 但是这样再使用的时候还是有点繁琐，接下来我们用装饰器实现

简单理解就是将添加了装饰器的函数(func)传入装饰器函数(decorator)中，在装饰器函数中创建内置函数(wrapper)，内置函数实现通用的功能并真正执行传入的函数(func)之后将返执行的函数结果在内置函数(wrapper)中返回，在装饰器函数(decorator)中将装饰器的内置函数(wrapper)作为返回对象返回

  1. def decorator(func):
  2.     def wrapper(*args, **kwargs):
  3.         """
  4.         define args and kwargs
  5.         """
  6.         # 通用的功能，这里我们认为输出传入的函数名称就是通用功能
  7.         print(func.__name__)
  8.         # 执行传入的方法
  9.         return func(*args, **kwargs)
  10.     # 返回当前方法的内置函数
  11.     return wrapper
  13. @decorator
  14. def func(a, b):
  15.     return a + b

 

这么一看的话大家应该就会觉得装饰器也很好理解了。

a. 无参装饰器

  1. def time_local(func):
  2.     def wrapper(*args, **kwargs):
  3.         start_time = time.time()
  4.         f = func(*args, **kwargs)
  5.         exec_time = time.time() - start_time
  6.         print('执行时间： {}'.format(exec_time))
  7.         return f
  8.     return wrapper
  9. @time_local
  10. def func1(a, b):
  11.     return a+b
  12.     
  13. @time_local
  14. def func2(a, b):
  15.     return a*b

 

上述代码块就是我们的装饰器实现，可以发现我们在计算其他操作的消耗的时间的时候只需要在函数前添加装饰器就可以了，这样就代码的改动就会尽可能少的改动，这就是简单的装饰器的实现方式和应用方式。

b. 有参装饰器
高级一点的我们可能需要对装饰器进行传参，这样的装饰器就是在无参装饰器外再包一层函数，如下

  1. def time_local_args(level):
  2.     def time_local(func):
  3.         def wrapper(*args, **kwargs):
  4.             if level:
  5.                 start_time = time.time()
  6.                 f = func(*args, **kwargs)
  7.                 exec_time = time.time() - start_time
  8.                 print('执行时间： {}'.format(exec_time))
  9.             else:
  10.                 f = func(*args, **kwargs)
  11.             return f
  12.         return wrapper
  13.     return time_local
  15. @time_local_args(level=True)
  16. def func(a, b):
  17.     return a+b

 

这样一看的话就很清晰了吧，装饰器就是一个函数内嵌套一个内置函数，在内置函数中实现通用功能以及执行被装饰的函数，嵌套函数的返回值为被装饰的函数，装饰器函数返回内置函数对象。

c. 再优雅一些的写法， 传参并封装成类且有参数的装饰器

  1. class TimeLocal:
  2.     def __init__(self, level):
  3.         self._level = level
  5.     def __call__(self, func, *args, **kwargs):
  6.         def wrapper(*args, **kwargs):
  7.             if self._level:
  8.                 start_time = time.time()
  9.                 f = func(*args, **kwargs)
  10.                 exec_time = time.time() - start_time
  11.                 print('执行时间： {}'.format(exec_time))
  12.             else:
  13.                 f = func(*args, **kwargs)
  14.             return f
  15.         return wrapper
  16.         
  17. @TimeLocal(level=True)
  18. def func4(a, b):
  19.     return b / a

 

d.偏函数与类结合构建装饰器

事实上，Python 对某个对象是否能通过装饰器（ @decorator）形式使用只有一个要求：decorator 必须是一个“可被调用（callable）的对象。

对于这个 callable 对象，我们最熟悉的就是函数了。

除函数之外，类也可以是 callable 对象，只要实现了call 函数（上面几个例子已经接触过了）。

还有容易被人忽略的偏函数其实也是 callable 对象。

接下来就来说说，如何使用 类和偏函数结合实现一个与众不同的装饰器。

如下所示，DelayFunc 是一个实现了 call 的类，delay 返回一个偏函数，在这里 delay 就可以做为一个装饰器。（以下代码摘自 Python工匠：使用装饰器的小技巧）

  1. import time
  2. import functools
  4. class DelayFunc:
  5.     def __init__(self,  duration, func):
  6.         self.duration = duration
  7.         self.func = func
  9.     def __call__(self, *args, **kwargs):
  10.         print(f'Wait for {self.duration} seconds...')
  11.         time.sleep(self.duration)
  12.         return self.func(*args, **kwargs)
  14.     def eager_call(self, *args, **kwargs):
  15.         print('Call without delay')
  16.         return self.func(*args, **kwargs)
  18. def delay(duration):
  19.     """
  20.     装饰器：推迟某个函数的执行。
  21.     同时提供 .eager_call 方法立即执行
  22.     """
  23.     # 此处为了避免定义额外函数，
  24.     # 直接使用 functools.partial 帮助构造 DelayFunc 实例
  25.     return functools.partial(DelayFunc, duration)
  26.    
  27. @delay(duration=2)
  28. def add(a, b):
  29.     return a+b

 

以上就是我们装饰器的理解以及几张实现的方式，最后我们看一下用在类上的装饰器的代码

  1. instances = {}
  3. def singleton(cls):
  4.     def get_instance(*args, **kw):
  5.         cls_name = cls.__name__
  6.         print('===== 1 ====')
  7.         if not cls_name in instances:
  8.             print('===== 2 ====')
  9.             instance = cls(*args, **kw)
  10.             instances[cls_name] = instance
  11.         return instances[cls_name]
  12.     return get_instance
  14. @singleton
  15. class User:
  16.     _instance = None
  18.     def __init__(self, name):
  19.         print('===== 3 ====')
  20.         self.name = name
  21. print(User('sdma'))
  23. >>> ===== 1 ====
  24. >>> ===== 2 ====
  25. >>> ===== 3 ====
  26. >>> <__main__.User object at 0x000001EAC67AEC48>

 

版权声明：本文为轻松学Python原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/hahaa/p/16120216.html