正文
Python的装饰器实例用法小结
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
这篇文章主要介绍了Python装饰器用法,结合实例形式总结分析了Python常用装饰器的概念、功能、使用方法及相关注意事项
一、装饰器是什么
python的装饰器本质上是一个Python函数 ，它可以让其他函数在不需要做任何代码变动的前提下 增加额外功能 ，装饰器的返回值也是一个 函数对象 。
它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。
概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
二、为什么需要装饰器
-
1、先来看一个简单例子： ```python
In [12]: def foo():
...: print('I am foo')
...:
- 2、增加需求
现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：
```python
In [13]: def foo():
...: print('I am foo')
...: print('foo is running')
...:
-
3、又有需求
假设现在有100个函数需要增加这个需求，并且后续可能还要对这一百个函数都增加执行前打印日志的需求。此时再一个个改会造成大量雷同的代码。 为了减少重复写代码，我们可以这样做，重新定义一个函数： 专门处理日志 ，日志处理完之后再执行真正的业务代码。
In [14]: def use_logging(func):
...: print('%s is running' % func.__name__)
...: func()
...: def bar():
...: print('I am bar')
...: use_logging(bar)
...:
#输出：
bar is running
I am bar
通过以上
use_logging
函数我们增加了日志功能，不管以后有多少函数需要增加日志或者修改日志的格式我们
只需要修改use_logging函数
，并执行
use_logging(被装饰的函数)
就达到了我们想要的效果。
In [18]: def use_logging(func): # use_logging装饰函数
...: print('%s is running' % func.__name__)
...: return func # 使用@ 语法糖要求装饰函数必须return一个函数对象
...:
...: @use_logging # @ 符号作为装饰器的语法糖
...: def bar():
...: print('i am bar')
...: bar()
...:
#输出
bar is running
i am bar
三、基础装饰器入门
-
1、装饰器语法糖
Python提供了 @ 符号作为装饰器的语法糖 ，使我们更方便的应用装饰函数。但是用语法糖要求装饰函数必须return一个函数对象。 因此我们将上面的func函数使用内嵌函数包裹并return。
装饰器 相当于执行了装饰函数use_logging后又返回被装饰函数bar，因此bar()被调用的时候相当于执行了两个函数。 等价于use_logging(bar)()
In [19]: def use_logging(func):
...: def _deco():
...: print('%s is running' %func.__name__)
...: func()
...: return _deco
...:
In [20]: @use_logging #注意： 把@ use_logging放在bar()函数定义的地方，相当于执行了语句： bar = use_logging(bar)
...: def bar(): #程序首先调用use_logging(bar)，得到的返回结果赋值给bar（注意：这里在Python中函数名只是个指向函数首地址的函数指针而已）
...: print(' i am bar')
...:
In [21]: bar() # bar()被调用的时候相当于执行了两个函数。等价于use_logging(bar)()
bar is running
i am bar
In [22]: bar
Out[22]: <function __main__.use_logging.<locals>._deco>
补充： 装饰器 其实就是一个以函数作为参数并返回一个替换函数的可执行函数。让我们从简单的开始，直到能写出实用的装饰器。
In [9]: def outer(some_func):
...: def inner():
...: print('before some_func')
...: ret = some_func() #1
...: return ret+1
...: return inner
...:
In [10]: def foo():
...: return 1
...:
In [11]: decorated = outer(foo) #2
In [12]: decorated()
before some_func
Out[12]: 2
请仔细看这个装饰器示例。首先，定义了一个带单个参数 some_func 的名为 outer 的函数。然后在 outer 内部定义了一个内嵌函数 inner。inner 函数将打印一行字符串然后调用 some_func，并在 #1 处获取其返回值。在每次 outer 被调用时，some_func 的值可能都会不同，但不论 some_func 是什么函数，都将调用它。最后，inner 返回 some_func() 的返回值加 1。在 #2 处可以看到，当调用赋值给 decorated 的返回函数时，得到的是一行文本输出和返回值 2，而非期望的调用 foo 的返回值 1。
我们可以说变量 decorated 是 foo 的装饰版——即 foo 加上一些东西。事实上，如果写了一个实用的装饰器，可能会想用装饰版来代替 foo，这样就总能得到“附带其他东西”的 foo 版本。用不着学习任何新的语法，通过将包含函数的变量重新赋值就能轻松做到这一点：
In [13]: foo = outer(foo)
In [14]: foo
Out[14]: <function __main__.outer.<locals>.inner>
In [15]: foo()
before some_func
Out[15]: 2
现在任意调用 foo() 都不会得到原来的 foo，而是新的装饰器版！
文章来源：简单 12 步理解 Python 装饰器
-
2、对带参数的函数进行装饰
现在我们的参数需要传入两个参数并计算值，因此我们需要对内层函数进行改动传入我们的两个参数a和b， 等价于use_logging(bar)(1,2)
In [23]: def use_logging(func):
...: def _deco(a,b):
...: print('%s is running' % func.__name__)
...: func(a,b)
...: return _deco
...:
In [24]: @use_logging
...: def bar(a,b):
...: print('i am bar: %s' %(a+b))
...: bar(1,2)
...:
bar is running
i am bar: 3
我们装饰的函数可能参数的个数和类型都不一样 ，每一次我们都需要对装饰器做修改吗？这样做当然是不科学的，因此我们使用Python的 变长参数 *args和**kwargs来解决我们的参数问题。
-
3、函数参数数量不确定
不带参数装饰器版本，这个格式适用于不带参数的装饰器。
经过以下修改我们已经适应了各种长度和类型的参数。这个版本的装饰器已经可以任意类型的无参数函数。
In [37]: def use_logging(func):
...: def _deco(*args,**kwargs):
...: print('%s is running' % func.__name__)
...: func(*args,**kwargs)
...: return _deco
...:
In [38]: @use_logging #不带参数装饰器
...: def bar(a,b):
...: print(' i am bar: %s' %(a+b))
...:
In [39]: @use_logging #不带参数装饰器
...: def foo(a,b,c):
...: print(' i am bar: %s' %(a+b+c))
...:
In [40]: bar(2,3)
bar is running
i am bar: 5
In [41]: foo(1,4,7)
foo is running
i am bar: 12
-
4、装饰器带参数
带参数的装饰器，这个格式适用于带参数的装饰器。
某些情况，我们需要让装饰器带上参数，那就需要编写一个 返回一个装饰器的高阶函数 ，写出来会更复杂。例如：
In [45]: def use_logging(level):
...: def _deco(func):
...: def _deco(*args,**kwargs):
...: if level == 'warn':
...: print('%s is running' % func.__name__)
...: return func(*args,**kwargs)
...: return _deco
...: return _deco
...:
In [46]: @use_logging(level = 'warn') #带参数的装饰器
...: def bar(a,b):
...: print('i am bar: %s' %(a+b))
...:
In [47]: bar(2,5)
bar is running
i am bar: 7
-
5、functools.wraps
使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring，__name__，参数列表，先看例子：
In [48]: def use_logging(func):
...: def _deco(*args,**kwargs):
...: print('%s is running' %func.__name__)
...: func(*args,**kwargs)
...: return _deco
...:
In [49]: @use_logging
...: def bar():
...: print('i am bar')
...: print(bar.__name__)
...:
In [50]: bar()
bar is running
i am bar
_deco #函数名变为_deco而不是bar，这个情况在使用反射的特性的时候就会造成问题。因此引入了functools.wraps解决这个问题。
使用functools.warps:
In [54]: import functools
...: def use_logging(func):
...: @functools.wraps(func)
...: def _deco(*args,**kwargs):
...: print("%s is running" % func.__name__)
...: func(*args,**kwargs)
...: return _deco
...:
In [55]: @use_logging
...: def bar():
...: print('i am bar')
...: print(bar.__name__)
...:
In [56]: bar()
bar is running
i am bar
bar #bar.__name__输出的结果是bar，正是我们想要的。
- 6、实现带参数和不带参数的装饰器自适应
In [57]: import functools
In [58]: def use_logging(arg):
...: if callable(arg): #判断传入的参数是否是函数，不带参数的装饰器调用这个分支
...: @functools.wraps(arg)
...: def _deco1(*args,**kwargs):
...: print('%s is running' %arg.__name__)
...: arg(*args,**kwargs)
...: return _deco1
...: else: #带参数的装饰器调用这个分支
...: def _deco1(func):
...: @functools.wraps(func)
...: def _deco2(*args,**kwargs):
...: if arg == 'warn':
...: print('warn %s is running' %func.__name__)
...: return func(*args,**kwargs)
...: return _deco2
...: return _deco1
...:
In [59]: @use_logging('warn') #带有参数的装饰器执行else分支语句
...: def bar():
...: print('i am bar')
...: print(bar.__name__)
...:
In [60]: bar()
warn bar is running #执行的是print('warn %s is running' %func.__name__)
i am bar
bar
In [61]: @use_logging #不带参数的装饰器执行if分支语句
...: def bar():
...: print('i am bar')
...: print(bar.__name__)
...:
In [62]: bar()
bar is running #执行的是 print("%s is running" % arg.__name__)
i am bar
bar
三、类装饰器
使用类装饰器可以实现带参数装饰器的效果，但实现的更加优雅简洁,而且可以通过继承来灵活的扩展。
- 1、类装饰器
In [68]: class loging(object): #类装饰器
...: def __init__(self,level="warn"):
...: self.level = level
...:
...: def __call__(self,func):
...: @functools.wraps(func)
...: def _deco(*args, **kwargs):
...: if self.level == "warn":
...: self.notify(func)
...: return func(*args, **kwargs)
...: return _deco
...:
...: def notify(self,func):
...: # loging只打日志，不做别的
...: print ("%s is running" % func.__name__)
...:
...:
...: @loging(level="warn") #执行__call__方法
...: def bar(a,b):
...: print('i am bar:%s'%(a+b))
In [69]: bar(1,3)
bar is running
i am bar:4
- 2、继承扩展类装饰器
In [72]: class email_loging(loging): #括号内的loging参数为上面的loging类装饰器，email_loging继承并扩展了loging类装饰器
...: """
...: 一个loging的实现版本，可以在函数调用时发送email给管理员
...: """
...: def __init__(self,email = 'admin = chj@ncu.edu.com',*args,**kwargs):
...: self.email = email
...: super(email_loging,self).__init__(*args,**kwargs)
...:
...: def notify(self,func):
...: #发送一份email到self.email
...: print('%s is running' %func.__name__)
...: print('sending email to %s' %self.email)
...:
In [73]: @email_loging(level = 'warn')
...: def bar(a,b):
...: print('i am bar: %s' %(a+b))
...:
In [74]: bar(1,3)
bar is running
sending email to admin = chj@ncu.edu.com
i am bar: 4
更多参考:
- 知乎：如何理解Python装饰器？
- 伯乐在线：简单 12 步理解 Python 装饰器
- Python装饰器用法实例总结
- Python装饰器原理与简单用法实例分析
