为什么在Python代码中装饰器很重要

开发 后端
要理解什么是装饰器,您首先需要熟悉Python处理函数的方式。从它的观点来看,函数和对象没有什么不同。它们有属性,可以重新分配:

 01什么是装饰器?

[[381721]]

要理解什么是装饰器,您首先需要熟悉Python处理函数的方式。从它的观点来看,函数和对象没有什么不同。它们有属性,可以重新分配:

 

  1. def func():  
  2.   print('hello from func')  
  3. func()  
  4. > hello from func  
  5. new_func = func  
  6. new_func()  
  7. > hello from func  
  8. print(new_func.__name__)  
  9. > func 

此外,你还可以将它们作为参数传递给其他函数:

 

  1. def func():  
  2.   print('hello from func')  
  3. def call_func_twice(callback):  
  4.   callback()  
  5.   callback()  
  6. call_func_twice(func)  
  7. > hello from func  
  8. > hello from func 

现在,我们介绍装饰器。装饰器(decorator)用于修改函数或类的行为。实现这一点的方法是定义一个返回另一个函数的函数(装饰器)。这听起来很复杂,但是通过这个例子你会理解所有的东西:

 

  1. def logging_decorator(func): 
  2.   def logging_wrapper(*args, **kwargs): 
  3.     print(f'Before {func.__name__}'
  4.     func(*args, **kwargs) 
  5.     print(f'After {func.__name__}'
  6.   return logging_wrapper 
  7.      
  8. @logging_decorator 
  9. def sum(x, y): 
  10.   print(x + y) 
  11.    
  12. sum(2, 5) 
  13. > Before sum 
  14. > 7 
  15. After sum 

让我们一步一步来:

  1. 首先,我们在第1行定义logging_decorator函数。它只接受一个参数,也就是我们要修饰的函数。
  2. 在内部,我们定义了另一个函数:logging_wrapper。然后返回logging_wrapper,并使用它来代替原来的修饰函数。
  3. 在第7行,您可以看到如何将装饰器应用到sum函数。
  4. 在第11行,当我们调用sum时,它不仅仅调用sum。它将调用logging_wrapper,它将在调用sum之前和之后记录日志。

02为什么需要装饰器

这很简单:可读性。Python因其清晰简洁的语法而备受赞誉,装饰器也不例外。如果有任何行为是多个函数共有的,那么您可能需要制作一个装饰器。下面是一些可能会派上用场的例子:

  1. 在运行时检查实参类型
  2. 基准函数调用
  3. 缓存功能的结果
  4. 计数函数调用
  5. 检查元数据(权限、角色等)
  6. 元编程

和更多…

现在我们将列出一些代码示例。

03例子

带有返回值的装饰器

假设我们想知道每个函数调用需要多长时间。而且,函数大多数时候都会返回一些东西,所以装饰器也必须处理它:

 

  1. def timer_decorator(func): 
  2.   def timer_wrapper(*args, **kwargs): 
  3.     import datetime                  
  4.     before = datetime.datetime.now()                      
  5.     result = func(*args,**kwargs)                 
  6.     after = datetime.datetime.now()                       
  7.     print "Elapsed Time = {0}".format(after-before)       
  8.     return result 
  9.      
  10. @timer_decorator 
  11. def sum(x, y): 
  12.   print(x + y) 
  13.   return x + y 
  14.    
  15. sum(2, 5) 
  16. > 7 
  17. > Elapsed Time = some time 

可以看到,我们将返回值存储在第5行的result中。但在返回之前,我们必须完成对函数的计时。这是一个没有装饰者就不可能实现的行为例子。

带有参数的装饰器

有时候,我们想要一个接受值的装饰器(比如Flask中的@app.route('/login'):

 

  1. def permission_decorator(permission): 
  2.   def _permission_decorator(func): 
  3.     def permission_wrapper(*args, **kwargs): 
  4.       if someUserApi.hasPermission(permission): 
  5.         result = func(*args, **kwargs) 
  6.         return result 
  7.       return None 
  8.     return permission wrapper 
  9.   return _permission_decorator 
  10.  
  11. @permission_decorator('admin'
  12. def delete_user(user): 
  13.   someUserApi.deleteUser(user

为了实现这一点,我们定义了一个额外的函数,它接受一个参数并返回一个装饰器。

带有类的装饰器

使用类代替函数来修饰是可能的。唯一的区别是语法,所以请使用您更熟悉的语法。下面是使用类重写的日志装饰器:

 

  1. class Logging:  
  2.    
  3.     def __init__(self, function):  
  4.         self.function = function  
  5.    
  6.     def __call__(self, *args, **kwargs): 
  7.       print(f'Before {self.function.__name__}'
  8.       self.function(*args, **kwargs) 
  9.       print(f'After {self.function.__name__}'
  10.    
  11.    
  12. @Logging 
  13. def sum(x, y): 
  14.   print(x + y) 
  15.  
  16. sum(5, 2) 
  17. > Before sum 
  18. > 7 
  19. After sum 

这样做的好处是,您不必处理嵌套函数。你所需要做的就是定义一个类并覆盖__call__方法。

装饰类

有时,您可能想要修饰类中的每个方法。你可以这样写

 

  1. class MyClass:  
  2.   @decorator  
  3.   def func1(self):  
  4.     pass  
  5.   @decorator  
  6.   def func2(self):  
  7.     pass 

但如果你有很多方法,这可能会失控。值得庆幸的是,有一种方法可以一次性装饰整个班级:

 

  1. def logging_decorator(func): 
  2.   def logging_wrapper(*args, **kwargs): 
  3.     print(f'Before {func.__name__}'
  4.     result = func(*args, **kwargs) 
  5.     print(f'After {func.__name__}'
  6.     return result 
  7.   return logging_wrapper 
  8.  
  9. def log_all_class_methods(cls): 
  10.     class NewCls(object): 
  11.       def __init__(self, *args, **kwargs): 
  12.         self.original = cls(*args, **kwargs) 
  13.        
  14.       def __getattribute__(self, s): 
  15.         try:     
  16.           x = super(NewCls,self).__getattribute__(s) 
  17.         except AttributeError:       
  18.           pass 
  19.         else
  20.           return x 
  21.         x = self.original.__getattribute__(s) 
  22.         if type(x) == type(self.__init__):  
  23.           return logging_decorator(x)                  
  24.         else
  25.           return x 
  26.     return NewCls 
  27.      
  28. @log_all_class_methods 
  29. class SomeMethods: 
  30.   def func1(self): 
  31.     print('func1'
  32.      
  33.   def func2(self): 
  34.     print('func2'
  35.      
  36. methods = SomeMethods() 
  37. methods.func1() 
  38. > Before func1 
  39. > func1 
  40. After func1 

现在,不要惊慌。这看起来很复杂,但逻辑是一样的:

  • 首先,我们让logging_decorator保持原样。它将应用于类的所有方法。
  • 然后我们定义一个新的装饰器:log_all_class_methods。它类似于普通的装饰器,但却返回一个类。
  • NewCls有一个自定义的__getattribute__。对于对原始类的所有调用,它将使用logging_decorator装饰函数。

内置的修饰符

您不仅可以定义自己的decorator,而且在标准库中也提供了一些decorator。我将列出与我一起工作最多的三个人:

@property -一个内置插件的装饰器,它允许你为类属性定义getter和setter。

@lru_cache - functools模块的装饰器。它记忆函数参数和返回值,这对于纯函数(如阶乘)很方便。

@abstractmethod——abc模块的装饰器。指示该方法是抽象的,且缺少实现细节。

责任编辑:华轩 来源: Python学会
相关推荐

2020-08-11 11:51:47

标准物联网IOT

2023-02-13 11:06:58

决策智能数据分析

2022-07-15 13:43:40

网络安全黑客

2022-01-10 23:39:18

Java测试开发

2022-11-07 11:22:33

2023-05-23 16:08:19

2024-01-08 13:28:00

5G低延迟

2020-12-30 13:30:38

数据中心计算机超级计算机

2021-04-03 12:39:20

SQL数据库编程语言

2022-05-11 15:08:16

加密货币私钥安全

2022-08-24 15:03:21

数据智能数据分析

2015-10-19 17:57:33

容器OpenStack微服务

2013-01-08 14:58:48

Firefox OS

2024-04-22 15:31:02

物联网

2022-11-15 14:52:09

虚拟孪生数字孪生

2010-10-26 13:44:15

2022-12-29 10:16:12

观察性系统监视

2023-05-06 10:43:21

开源数据分析

2019-09-18 11:54:05

2023-09-18 16:46:07

点赞
收藏

51CTO技术栈公众号