devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Python】一文弄懂python装饰器（附源码例子）_python 装饰器

作者：IT小白 | 2024-03-29 17:00:17

赞

踩

python 装饰器

目录

前言

一、什么是装饰器

二、为什么要用装饰器

三、简单的装饰器

四、装饰器的语法糖@

五、装饰器传参

六、带参数的装饰器

七、类装饰器

八、带参数的类装饰器

九、装饰器的顺序

总结

写在后面

前言

最近有人问我装饰器是什么，我就跟他说，其实就是装饰器就是类似于女孩子的发卡。你喜欢的一个女孩子，她可以有很多个发卡，而当她戴上不同的发卡，她的头顶上就是装饰了不同的发卡。但是你喜欢的女孩子还是你喜欢的女孩子。如果还觉得不理解的话，装饰器就是咱们的手机壳，你尽管套上了手机壳，但并不影响你的手机功能，可你的手机还是该可以给你玩，该打电话打电话，该玩游戏玩游戏，该收藏攻城狮白玉的博客就收藏攻城狮白玉的博客。而你的手机就变成了带手机壳的手机。

装饰器就是python的一个拦路虎，你干或者不干它，它都在那里。如果你想学会高级的python用法，装饰器就是你这个武松必须打倒的一只虎。

本文的环境如下：

win10，python3.7

一、什么是装饰器

装饰器是给现有的模块增添新的小功能，可以对原函数进行功能扩展，而且还不需要修改原函数的内容，也不需要修改原函数的调用。

装饰器的使用符合了面向对象编程的开放封闭原则。

开放封闭原则主要体现在两个方面：

  1. 对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。
  2. 对修改封闭，意味着类一旦设计完成，就可以独立其工作，而不要对类尽任何修改。

二、为什么要用装饰器

使用装饰器之前，我们要知道，其实python里是万物皆对象，也就是万物都可传参。

函数也可以作为函数的参数进行传递的。

通过下面这个简单的例子可以更直观知道函数名是如何直接作为参数进行传递

  1. def baiyu():
  2.     print("我是攻城狮白玉")
  3.  
  4.  
  5. def blog(name):
  6.     print('进入blog函数')
  7.     name()
  8.     print('我的博客是 https://blog.csdn.net/zhh763984017')
  9.  
  10.  
  11. if __name__ == '__main__':
  12.     func = baiyu  # 这里是把baiyu这个函数名赋值给变量func
  13.     func()  # 执行func函数
  14.     print('------------')
  15.     blog(baiyu)  # 把baiyu这个函数作为参数传递给blog函数

执行结果如下所示：

 接下来，我想知道这baiyu和blog两个函数分别的执行时间是多少，我就把代码修改如下：

  1. import time
  2.  
  3.  
  4. def baiyu():
  5.     t1 = time.time()
  6.     print("我是攻城狮白玉")
  7.     time.sleep(2)
  8.     print("执行时间为：", time.time() - t1)
  9.  
  10.  
  11. def blog(name):
  12.     t1 = time.time()
  13.     print('进入blog函数')
  14.     name()
  15.     print('我的博客是 https://blog.csdn.net/zhh763984017')
  16.     print("执行时间为：", time.time() - t1)
  17.  
  18.  
  19. if __name__ == '__main__':
  20.     func = baiyu  # 这里是把baiyu这个函数名赋值给变量func
  21.     func()  # 执行func函数
  22.     print('------------')
  23.     blog(baiyu)  # 把baiyu这个函数作为参数传递给blog函数

 

 上述的改写已经实现了我需要的功能，但是，当我有另外一个新的函数【python_blog_list】，具体如下：

  1. def python_blog_list():
  2.     print('''【Python】爬虫实战，零基础初试爬虫下载图片（附源码和分析过程）
  3.     https://blog.csdn.net/zhh763984017/article/details/119063252 ''')
  4.     print('''【Python】除了多线程和多进程，你还要会协程
  5.     https://blog.csdn.net/zhh763984017/article/details/118958668 ''')
  6.     print('''【Python】爬虫提速小技巧，多线程与多进程（附源码示例）
  7.     https://blog.csdn.net/zhh763984017/article/details/118773313 ''')
  8.     print('''【Python】爬虫解析利器Xpath，由浅入深快速掌握（附源码例子）
  9.     https://blog.csdn.net/zhh763984017/article/details/118634945 ''')

也需要计算函数执行时间的，那按之前的逻辑，就是改写如下：

  1. def python_blog_list():
  2.     t1 = time.time()
  3.     print('''【Python】爬虫实战，零基础初试爬虫下载图片（附源码和分析过程）
  4.     https://blog.csdn.net/zhh763984017/article/details/119063252 ''')
  5.     print('''【Python】除了多线程和多进程，你还要会协程
  6.     https://blog.csdn.net/zhh763984017/article/details/118958668 ''')
  7.     print('''【Python】爬虫提速小技巧，多线程与多进程（附源码示例）
  8.     https://blog.csdn.net/zhh763984017/article/details/118773313 ''')
  9.     print('''【Python】爬虫解析利器Xpath，由浅入深快速掌握（附源码例子）
  10.     https://blog.csdn.net/zhh763984017/article/details/118634945 ''')
  11.     print("执行时间为：", time.time() - t1)

如果也要这样子写的话，不就重复造轮子了吗？虽说人类的本质是鸽王和复读机，但作为一个优秀的cv攻城狮（ctrl+c和ctrl+v）肯定是要想办法偷懒的呀

 

装饰器，就是可以让我们拓展一些原有函数没有的功能。

三、简单的装饰器

基于上面的函数执行时间的需求，我们就手写一个简单的装饰器进行实现。

  1. import time
  2.  
  3.  
  4. def baiyu():
  5.     print("我是攻城狮白玉")
  6.     time.sleep(2)
  7.  
  8.  
  9. def count_time(func):
  10.     def wrapper():
  11.         t1 = time.time()
  12.         func()
  13.         print("执行时间为：", time.time() - t1)
  14.  
  15.     return wrapper
  16.  
  17.  
  18. if __name__ == '__main__':
  19.     baiyu = count_time(baiyu)  # 因为装饰器 count_time(baiyu) 返回的时函数对象 wrapper，这条语句相当于  baiyu = wrapper
  20.     baiyu()  # 执行baiyu()就相当于执行wrapper()

这里的count_time是一个装饰器，装饰器函数里面定义一个wrapper函数，把func这个函数当作参数传入，函数实现的功能是把func包裹起来，并且返回wrapper函数。wrapper函数体就是要实现装饰器的内容。

当然，这里的wrapper函数名是可以自定义的，只要你定义的函数名，跟你return的函数名是相同的就好了

四、装饰器的语法糖@

你如果看过其他python项目里面的代码里，难免会看到@符号，这个@符号就是装饰器的语法糖。因此上面简单的装饰器还是可以通过语法糖来实现的，这样就可以省去

baiyu = count_time(baiyu)

这一句代码，而直接调用baiyu()这个函数

换句话说，其实使用装饰器的是，默认传入的参数就是被装饰的函数。

  1. import time
  2.  
  3.  
  4. def count_time(func):
  5.     def wrapper():
  6.         t1 = time.time()
  7.         func()
  8.         print("执行时间为：", time.time() - t1)
  9.  
  10.     return wrapper
  11.  
  12.  
  13. @count_time
  14. def baiyu():
  15.     print("我是攻城狮白玉")
  16.     time.sleep(2)
  17.  
  18.  
  19. if __name__ == '__main__':
  20.     # baiyu = count_time(baiyu)  # 因为装饰器 count_time(baiyu) 返回的时函数对象 wrapper，这条语句相当于  baiyu = wrapper
  21.     # baiyu()  # 执行baiyu()就相当于执行wrapper()
  22.  
  23.     baiyu()  # 用语法糖之后，就可以直接调用该函数了

五、装饰器传参

当我们的被装饰的函数是带参数的，此时要怎么写装饰器呢？

上面我们有定义了一个blog函数是带参数的

  1. def blog(name):
  2.     print('进入blog函数')
  3.     name()
  4.     print('我的博客是 https://blog.csdn.net/zhh763984017')

此时我们的装饰器函数要优化一下下，修改成为可以接受任意参数的装饰器

  1. def count_time(func):
  2.     def wrapper(*args,**kwargs):
  3.         t1 = time.time()
  4.         func(*args,**kwargs)
  5.         print("执行时间为：", time.time() - t1)
  6.  
  7.     return wrapper

此处，我们的wrapper函数的参数为*args和**kwargs，表示可以接受任意参数

这时我们就可以调用我们的装饰器了。

  1. import time
  2.  
  3.  
  4. def count_time(func):
  5.     def wrapper(*args, **kwargs):
  6.         t1 = time.time()
  7.         func(*args, **kwargs)
  8.         print("执行时间为：", time.time() - t1)
  9.  
  10.     return wrapper
  11.  
  12.  
  13. @count_time
  14. def blog(name):
  15.     print('进入blog函数')
  16.     name()
  17.     print('我的博客是 https://blog.csdn.net/zhh763984017')
  18.  
  19.  
  20. if __name__ == '__main__':
  21.     # baiyu = count_time(baiyu)  # 因为装饰器 count_time(baiyu) 返回的时函数对象 wrapper，这条语句相当于  baiyu = wrapper
  22.     # baiyu()  # 执行baiyu()就相当于执行wrapper()
  23.  
  24.     # baiyu()  # 用语法糖之后，就可以直接调用该函数了
  25.     blog(baiyu)

六、带参数的装饰器

前面咱们知道，装饰器函数也是函数，既然是函数，那么就可以进行参数传递，咱们怎么写一个带参数的装饰器呢？

前面咱们的装饰器只是实现了一个计数，那么我想在使用该装饰器的时候，传入一些备注的msg信息，怎么办呢？咱们一起看一下下面的代码

  1. import time
  2.  
  3.  
  4. def count_time_args(msg=None):
  5.     def count_time(func):
  6.         def wrapper(*args, **kwargs):
  7.             t1 = time.time()
  8.             func(*args, **kwargs)
  9.             print(f"[{msg}]执行时间为：", time.time() - t1)
  10.  
  11.         return wrapper
  12.  
  13.     return count_time
  14.  
  15.  
  16. @count_time_args(msg="baiyu")
  17. def fun_one():
  18.     time.sleep(1)
  19.  
  20.  
  21. @count_time_args(msg="zhh")
  22. def fun_two():
  23.     time.sleep(1)
  24.  
  25.  
  26. @count_time_args(msg="mylove")
  27. def fun_three():
  28.     time.sleep(1)
  29.  
  30.  
  31. if __name__ == '__main__':
  32.     fun_one()
  33.     fun_two()
  34.     fun_three()

咱们基于原来的count_time函数外部再包一层用于接收参数的count_time_args，接收回来的参数就可以直接在内部的函数里面调用了。上述代码执行效果如下：

 

七、类装饰器

上面咱们一起学习了怎么写装饰器函数，在python中，其实也可以同类来实现装饰器的功能，称之为类装饰器。类装饰器的实现是调用了类里面的__call__函数。类装饰器的写法比我们装饰器函数的写法更加简单。

当我们将类作为一个装饰器，工作流程：

  • 通过__init__（）方法初始化类
  • 通过__call__（）方法调用真正的装饰方法
  1. import time
  2.  
  3.  
  4. class BaiyuDecorator:
  5.     def __init__(self, func):
  6.         self.func = func
  7.         print("执行类的__init__方法")
  8.  
  9.     def __call__(self, *args, **kwargs):
  10.         print('进入__call__函数')
  11.         t1 = time.time()
  12.         self.func(*args, **kwargs)
  13.         print("执行时间为：", time.time() - t1)
  14.  
  15.  
  16. @BaiyuDecorator
  17. def baiyu():
  18.     print("我是攻城狮白玉")
  19.     time.sleep(2)
  20.  
  21.  
  22. def python_blog_list():
  23.     time.sleep(5)
  24.     print('''【Python】爬虫实战，零基础初试爬虫下载图片（附源码和分析过程）
  25.     https://blog.csdn.net/zhh763984017/article/details/119063252 ''')
  26.     print('''【Python】除了多线程和多进程，你还要会协程
  27.     https://blog.csdn.net/zhh763984017/article/details/118958668 ''')
  28.     print('''【Python】爬虫提速小技巧，多线程与多进程（附源码示例）
  29.     https://blog.csdn.net/zhh763984017/article/details/118773313 ''')
  30.     print('''【Python】爬虫解析利器Xpath，由浅入深快速掌握（附源码例子）
  31.     https://blog.csdn.net/zhh763984017/article/details/118634945 ''')
  32.  
  33.  
  34. @BaiyuDecorator
  35. def blog(name):
  36.     print('进入blog函数')
  37.     name()
  38.     print('我的博客是 https://blog.csdn.net/zhh763984017')
  39.  
  40.  
  41. if __name__ == '__main__':
  42.     baiyu()
  43.     print('--------------')
  44.     blog(python_blog_list)

八、带参数的类装饰器

当装饰器有参数的时候，__init__() 函数就不能传入func（func代表要装饰的函数）了，而func是在__call__函数调用的时候传入的。

 

  1. class BaiyuDecorator:
  2.     def __init__(self, arg1, arg2):  # init()方法里面的参数都是装饰器的参数
  3.         print('执行类Decorator的__init__()方法')
  4.         self.arg1 = arg1
  5.         self.arg2 = arg2
  6.  
  7.     def __call__(self, func):  # 因为装饰器带了参数，所以接收传入函数变量的位置是这里
  8.         print('执行类Decorator的__call__()方法')
  9.  
  10.         def baiyu_warp(*args):  # 这里装饰器的函数名字可以随便命名，只要跟return的函数名相同即可
  11.             print('执行wrap()')
  12.             print('装饰器参数：', self.arg1, self.arg2)
  13.             print('执行' + func.__name__ + '()')
  14.             func(*args)
  15.             print(func.__name__ + '()执行完毕')
  16.  
  17.         return baiyu_warp
  18.  
  19.  
  20. @BaiyuDecorator('Hello', 'Baiyu')
  21. def example(a1, a2, a3):
  22.     print('传入example()的参数：', a1, a2, a3)
  23.  
  24.  
  25. if __name__ == '__main__':
  26.     print('准备调用example()')
  27.     example('Baiyu', 'Happy', 'Coder')
  28.     print('测试代码执行完毕')

建议各位同学好好比对一下这里的代码和不带参数的装饰器代码的区别，加深理解。

九、装饰器的顺序

一个函数可以被多个装饰器进行装饰，那么装饰器的执行顺序是怎么样的呢？咱们执行一下下面的代码就清楚了

  1. def BaiyuDecorator_1(func):
  2.     def wrapper(*args, **kwargs):
  3.         func(*args, **kwargs)
  4.         print('我是装饰器1')
  5.  
  6.     return wrapper
  7.  
  8. def BaiyuDecorator_2(func):
  9.     def wrapper(*args, **kwargs):
  10.         func(*args, **kwargs)
  11.         print('我是装饰器2')
  12.  
  13.     return wrapper
  14.  
  15. def BaiyuDecorator_3(func):
  16.     def wrapper(*args, **kwargs):
  17.         func(*args, **kwargs)
  18.         print('我是装饰器3')
  19.  
  20.     return wrapper
  21.  
  22. @BaiyuDecorator_1
  23. @BaiyuDecorator_2
  24. @BaiyuDecorator_3
  25. def baiyu():
  26.     print("我是攻城狮白玉")
  27.  
  28.  
  29. if __name__ == '__main__':
  30.     baiyu()

由输出结果可知，在装饰器修饰完的函数，在执行的时候先执行原函数的功能，然后再由里到外依次执行装饰器的内容。

我们带三个装饰器的函数的代码如下：

 

  1. @BaiyuDecorator_1
  2. @BaiyuDecorator_2
  3. @BaiyuDecorator_3
  4. def baiyu():
  5.     print("我是攻城狮白玉")

上述的代码可以看作如下代码，就能理解为何是由里到外执行了

baiyu = BaiyuDecorator_1 (BaiyuDecorator_2 (BaiyuDecorator_3(baiyu)))

总结

本文由浅入深介绍了python的装饰器，并且通过代码展现了如何自己手写装饰器函数和类装饰器。

写在后面

如果觉得有用的话，麻烦一键三连支持一下攻城狮白玉，并把本文分享给更多的小伙伴。你的简单支持，我的无限创作动力

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/336308
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号