一个已经存在 10 年,却被严重低估的库

开发 后端
今天介绍的是一个已经存在十三年,但是依旧不红的库 decorator,好像很少有人知道他的存在一样。

本文转载自微信公众号“写代码的明哥”(Cool-Python)。

大家好,我是明哥。

今天介绍的是一个已经存在十三年,但是依旧不红的库 decorator,好像很少有人知道他的存在一样。

这个库可以帮你做什么呢 ?

[[394601]]

其实很简单,就是可以帮你更方便地写python装饰器代码,更重要的是,它让 Python 中被装饰器装饰后的方法长得更像装饰前的方法。

本篇文章不会过多的向你介绍装饰器的基本知识,我会默认你知道什么是装饰器,并且懂得如何写一个简单的装饰器。

不了解装饰器的可以先去阅读我之前写的文章,非常全且详细的介绍了装饰器的各种实现方法。

1. 常规的装饰器

下面这是一个最简单的装饰器示例,在运行 myfunc 函数的前后都会打印一条日志。

  1. def deco(func): 
  2.     def wrapper(*args, **kw): 
  3.         print("Ready to run task") 
  4.         func(*args, **kw) 
  5.         print("Successful to run task") 
  6.     return wrapper 
  7.  
  8. @deco 
  9. def myfunc(): 
  10.     print("Running the task") 
  11.  
  12. myfunc() 

装饰器使用起来,似乎有些高端和魔幻,对于一些重复性的功能,往往我们会封装成一个装饰器函数。

在定义一个装饰器的时候,我们都需要像上面一样机械性的写一个嵌套的函数,对装饰器原理理解不深的初学者,往往过段时间就会忘记如何定义装饰器。

有一些比较聪明的同学,会利用 PyCharm 来自动生成装饰器模板

然后要使用的时候,直接敲入 deco 就会生成一个简单的生成器代码,提高编码的准备效率 


2. 使用神库

使用 PyCharm 的 Live Template ,虽然能降低编写装饰器的难度,但却要依赖 PyCharm 这一专业的代码编辑器。

这里,明哥要教你一个更加简单的方法,使用这个方法呢,你需要先安装一个库 :decorator,使用 pip 可以很轻易地去安装它

  1. $ python3 -m pip install decorator 

从库的名称不难看出,这是一个专门用来解决装饰器问题的第三方库。

有了它之后,你会惊奇的发现,以后自己定义的装饰器,就再也不需要写嵌套的函数了

  1. from decorator import decorator 
  2.  
  3. @decorator 
  4. def deco(func, *args, **kw): 
  5.     print("Ready to run task") 
  6.     func(*args, **kw) 
  7.     print("Successful to run task") 
  8.  
  9. @deco 
  10. def myfunc(): 
  11.     print("Running the task") 
  12.  
  13. myfunc() 

deco 作为装饰函数,第一个参数是固定的,都是指被装饰函数,而后面的参数都固定使用 可变参数 *args 和 **kw 的写法,代码被装饰函数的原参数。

这种写法,不得不说,更加符合直觉,代码的逻辑也更容易理解。

3. 带参数的装饰器可用?

装饰器根据有没有携带参数,可以分为两种

第一种:不带参数,最简单的示例,上面已经举例

  1. def decorator(func): 
  2.     def wrapper(*args, **kw): 
  3.         func(*args, **kw) 
  4.     return wrapper 

第二种:带参数,这就相对复杂了,理解起来了也不是那么容易。

  1. def decorator(arg1, arg2): 
  2.     def wrapper(func): 
  3.         def deco(*args, **kwargs) 
  4.             func(*args, **kwargs) 
  5.         return deco 
  6.     return wrapper 

那么对于需要带参数的装饰器,decorator 是否也一样能很好的支持呢?

下面是一个官方的示例

  1. from decorator import decorator 
  2.  
  3. @decorator 
  4. def warn_slow(func, timelimit=60, *args, **kw): 
  5.     t0 = time.time() 
  6.     result = func(*args, **kw) 
  7.     dt = time.time() - t0 
  8.     if dt > timelimit: 
  9.         logging.warn('%s took %d seconds', func.__name__, dt) 
  10.     else: 
  11.         logging.info('%s took %d seconds', func.__name__, dt) 
  12.     return result 
  13.  
  14. @warn_slow(timelimit=600)  # warn if it takes more than 10 minutes 
  15. def run_calculation(tempdir, outdir): 
  16.     pass 

可以看到:

  • 装饰函数的第一个参数,还是被装饰器 func ,这个跟之前一样
  • 而第二个参数 timelimit 写成了位置参数的写法,并且有默认值
  • 再往后,就还是跟原来一样使用了可变参数的写法

不难推断,只要你在装饰函数中第二个参数开始,使用了非可变参数的写法,这些参数就可以做为装饰器调用时的参数。

4. 签名问题有解决?

我们在自己写装饰器的时候,通常都会顺手加上一个叫 functools.wraps 的装饰器,我想你应该也经常见过,那他有啥用呢?

先来看一个例子

  1. def wrapper(func): 
  2.     def inner_function(): 
  3.         pass 
  4.     return inner_function 
  5.  
  6. @wrapper 
  7. def wrapped(): 
  8.     pass 
  9.  
  10. print(wrapped.__name__) 
  11. #inner_function 

为什么会这样子?不是应该返回 func 吗?

这也不难理解,因为上边执行func 和下边 decorator(func) 是等价的,所以上面 func.__name__ 是等价于下面decorator(func).__name__ 的,那当然名字是 inner_function

  1. def wrapper(func): 
  2.     def inner_function(): 
  3.         pass 
  4.     return inner_function 
  5.  
  6. def wrapped(): 
  7.     pass 
  8.  
  9. print(wrapper(wrapped).__name__) 
  10. #inner_function 

目前,我们可以看到当一个函数被装饰器装饰过后,它的签名信息会发生变化(譬如上面看到的函数名)

那如何避免这种情况的产生?

解决方案就是使用我们前面所说的 functools .wraps 装饰器。

它的作用就是将 被修饰的函数(wrapped) 的一些属性值赋值给 修饰器函数(wrapper) ,最终让属性的显示更符合我们的直觉。

  1. from functools import wraps 
  2.  
  3. def wrapper(func): 
  4.     @wraps(func) 
  5.     def inner_function(): 
  6.         pass 
  7.     return inner_function 
  8.  
  9. @wrapper 
  10. def wrapped(): 
  11.     pass 
  12.  
  13. print(wrapped.__name__) 
  14. # wrapped 

那么问题就来了,我们使用了 decorator 之后,是否还会存在这种签名的问题呢?

写个例子来验证一下就知道啦

  1. from decorator import decorator 
  2.  
  3. @decorator 
  4. def deco(func, *args, **kw): 
  5.     print("Ready to run task") 
  6.     func(*args, **kw) 
  7.     print("Successful to run task") 
  8.  
  9. @deco 
  10. def myfunc(): 
  11.     print("Running the task") 
  12.  
  13. print(myfunc.__name__) 

输出的结果是 myfunc,说明 decorator 已经默认帮我们处理了一切可预见的问题。

5. 总结一下

decorator 是一个提高装饰器编码效率的第三方库,它适用于对装饰器原理感到困惑的新手,可以让你很轻易的写出更符合人类直觉的代码。

对于带参数装饰器的定义,是非常复杂的,它需要要写多层的嵌套函数,并且需要你熟悉各个参数的传递路径,才能保证你写出来的装饰器可以正常使用。

这时候,只要用上 decorator 这个库,你就可以很轻松的写出一个带参数的装饰器。同时你也不用担心他会出现签名问题,这些它都为你妥善的处理好了。

这么棒的一个库,推荐你使用起来。

 

责任编辑:赵宁宁 来源: Python编程时光
相关推荐

2021-05-21 07:26:15

DataSource接口数据库

2023-02-14 07:50:30

Python模块

2013-06-28 17:28:04

推送

2020-04-27 11:24:14

漏洞iPhone苹果

2023-11-09 09:02:26

TypeScriptas const

2022-09-16 09:13:27

代码偷懒方法

2022-09-15 12:22:25

cookieDOS 漏洞网络攻击

2022-05-31 19:08:07

漏洞网络攻击

2023-01-16 18:16:49

CinnamonLinux桌面环境

2018-08-20 20:22:05

区块链互联网未来

2010-08-31 12:06:34

2017-08-31 13:06:32

2016-01-27 13:40:12

IBM Watson/

2011-11-15 11:16:40

华为电信设备

2020-07-13 07:27:16

Python开发

2013-01-14 09:36:54

程序员程序员价值

2020-12-10 06:27:19

技术人

2015-07-07 17:28:48

2021-01-25 09:20:04

数据库架构分布式

2022-11-10 08:31:09

原生图数据库可视化
点赞
收藏

51CTO技术栈公众号