装饰器可以使函数执行前和执行后分别执行其他的附加功能，这种在代码运行期间动态增加功能的方式，称之为"装饰器"(Decorator)，装饰器的功能非常强大，装饰器一般接受一个函数对象作为参数，以对其进行增强，相当于C++中的构造函数，与析构函数。
装饰器本质上是一个python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象.它经常用于有迫切需求的场景,比如：插入日志、性能测试、事务处理、缓存、权限校验等场景.装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用.
- 装饰器本身也是一个函数,其作用是,用于装饰其他函数.
- 装饰器是一个闭包函数是嵌套函数,通过外层函数提供嵌套函数的环境
- 装饰器在权限控制,增加额外功能,如增加记录日志,缓存处理,发送邮件用的比较多
6.1 无参装饰器
原函数中不带参数的装饰器,如下例子假设：我定义了一个函数lyshark(),现在想要在不改变原来函数定义的情况下,在函数运行前打印一段话,函数运行后打印另一段话,此时我们可以使用装饰器的装饰功能来简单的实现这个需求.
>>> import os
>>> import sys
>>>
>>> def outer(function):
def inner():
print("主函数开始执行前,会先执行我!")
result=function()
print("主函数执行结束后,要在执行我!")
return result
return inner
# (1) @ + 函数名,直接作用在需要装饰的函数上一行
# (2) 自动执行outer函数并且将下面的函数名lyshark()当做参数传递到outer()
# (3) 将outer函数的返回值inner,重新赋值给lyshark()函数
>>> @outer
def lyshark():
print("lyshark 的主函数体,装饰器在装饰我(*^_^*)")
return "check ok"
#==调用并执行函数,结果如下==========================================
>>> ret=lyshark()
主函数开始执行前,会先执行我!
lyshark 的主函数体,装饰器在装饰我(*^_^*)
主函数执行结束后,要在执行我!
>>> print("lyshark()函数的返回值: ",ret)
lyshark()函数的返回值: check
上方代码的执行流程是这样的,步骤如下:
- 1.当我们调用lyshark()函数时,会自动检查lyshark()函数上是否有装饰器
- 2.如果有则将lyshark()函数的指针,传递给装饰器outer(function)
- 3.outer(function)接到指针后,执行嵌套函数内的inner(),则先执行print打印一段话
- 4.由于lyshark()函数指针,传递给了function变量,执行function()则相当于执行lyshark()
- 5.接着最后一步执行打印一段结束的话,并执行返回,返回inner
6.2 有参装饰器
原函数带一个参数的装饰器: 我们在以上的案例中,给装饰器添加一个参数,并在内部使用这个参数.
>>> import os
>>> import sys
>>>
>>> def outer(function):
def inner(args):
print("主函数开始执行前,会先执行我!")
ret=function(args)
print("主函数执行结束后,要在执行我!")
return ret
return inner
>>> @outer
def lyshark(args):
print(args)
return 0
#==调用并执行函数,结果如下==========================================
>>> ret=lyshark("hello world!")
主函数开始执行前,会先执行我!
hello world!
主函数执行结束后,要在执行我!
>>> print("lyshark 的返回值是：",ret)
lyshark() 函数的返回值是： 0
原函数带两个参数的装饰器: 接下来继续演示一下,带有两个参数的装饰器,3个4个,以此类推.
>>> import os
>>> import sys
>>>
>>>
>>> def outer(function):
def inner(x,y):
print("主函数开始执行前,会先执行我!")
ret=function(x,y)
print("主函数执行结束后,要在执行我!")
return ret
return inner
>>> @outer
def lyshark(x,y):
print(x,y)
return 0
#==调用并执行函数,结果如下==========================================
>>> ret=lyshark("Hello","LyShark")
主函数开始执行前,会先执行我!
Hello LyShark
主函数执行结束后,要在执行我!
>>> print("lyshark() 函数的返回值是：",ret)
lyshark() 函数的返回值是： 0
传递一个万能参数: 装饰器也可传递一个万能参数,通过此参数传递列表字典等.
>>> import os
>>> import sys
>>>
>>> def outer(function):
def inner(*args,**kwargs):
print("主函数开始执行前,会先执行我!")
ret=function(*args,**kwargs)
print("主函数执行结束后,要在执行我!")
return ret
return inner
>>> @outer
def lyshark(*args):
print(args)
return 0
#==调用并执行函数,结果如下==========================================
>>> num=[1,2,3,4,5]
>>> ret=lyshark(num)
主函数开始执行前,会先执行我!
([1, 2, 3, 4, 5],)
主函数执行结束后,要在执行我!
>>>
>>> print("lyshark() 函数的返回值是：",ret)
lyshark() 函数的返回值是： 0
#==调用并执行函数,结果如下==========================================
@outer
def lyshark_kw(*args,**kwargs):
print(args,kwargs)
return 0
num=[1,2,3,4,5]
kw={"1001":"admin","1002":"guest"}
ret=lyshark_kw(num,kw)
一次使用两个装饰器装饰函数: 如果一个装饰器不够用的话,我们可以使用两个装饰器,首先将函数与内层装饰器结合然后在与外层装饰器相结合,要理解使用@语法的时候到底执行了什么,是理解装饰器的关键.
>>> import os
>>> import sys
>>>
>>> def outer2(function2):
def inner2(*args,**kwargs):
print("装饰器2--->【开始】")
ret=function2(*args,**kwargs)
print("装饰器2--->【结束】")
return ret
return inner2
>>> def outer1(function1):
def inner1(*args,**kwargs):
print("装饰器1--->【开始】")
ret=function1(*args,**kwargs)
print("装饰器1--->【结束】")
return ret
return inner1
@outer2
@outer1
def lyshark():
print("lyshark 函数被执行了")
#==调用并执行函数,结果如下==========================================
>>> lyshark()
装饰器2--->【开始】
装饰器1--->【开始】
lyshark 函数执行了
装饰器1--->【结束】
装饰器2--->【结束】
#==调用并执行函数,结果如下==========================================
@outer1
@outer2
def lyshark_and():
print("lyshark_and 函数被执行了")
>>> lyshark_and()
装饰器1--->【开始】
装饰器2--->【开始】
lyshark_and 函数执行了
装饰器2--->【结束】
装饰器1--->【结束】
6.3 带参装饰器
前面的装饰器本身没有带参数,如果要写一个带参数的装饰器怎么办,那么我们就需要写一个三层的装饰器,而且前面写的装饰器都不太规范,下面来写一个比较规范带参数的装饰器,下面来看一下代码,大家可以将下面的代码自我运行一下.
给装饰器本身添加参数: 接下来我们将给装饰器本身添加一些参数,使其能够实现参数传递.
>>> import functools
>>> import sys
>>>
>>> def lyshark(temp=""): #指定装饰器默认参数
def decorator(function): #定义装饰器
@functools.wraps(function) #使被装饰的装饰器的函数名不改变
def wrapper(*args,**kwargs):
print("主函数开始执行前,会先执行我!")
print("{}:{}".format(temp,function.__name__)) #这里调用了装饰器temp变量
ret=function(*args,**kwargs)
print("主函数执行结束后,要在执行我!")
return ret
return wrapper
return decorator
#==调用并执行函数,结果如下==========================================
>>> #如果不给装饰器加参数,那么这个装饰器将使用默认参数 temp="",来填充
>>> @lyshark()
def test(x):
print(x+100)
>>> test(100)
主函数开始执行前,会先执行我!
:test #这里由于没有传递参数则第一项为空,第二项是函数名称`function.__name__`取出的
主函数执行结束后,要在执行我!
#==调用并执行函数,结果如下==========================================
>>> #下面是给装饰器一个参数,将不是用默认参数 temp="",将变成 temp="LyShark"
>>> @lyshark("LyShark")
def test(x):
print(x+100)
>>> test(100)
主函数开始执行前,会先执行我!
LyShark:test
主函数执行结束后,要在执行我!
给装饰器本身添加参数: 接下来我们将给装饰器本身添加两个参数,使其能够传递多个参数.
>>> import sys
>>> import os
>>>
>>> def lyshark(x="Hello",y="LyShark"):
def decorator(function):
def wrapper():
print("主函数执行前,应先执行我！")
print(x,y)
ret=function()
print("主函数执行后,要执行我！")
return ret
return wrapper
return decorator
#==调用并执行函数,结果如下==========================================
>>> #使用默认参数的装饰器:此时 x="Hello" y="LyShark"
>>> @lyshark()
def test():
print("我是test(),主函数,装饰器在装饰我")
>>> test()
主函数执行前,应先执行我！
Hello LyShark
我是test(),主函数,装饰器在装饰我
主函数执行后,要执行我！
#==调用并执行函数,结果如下==========================================
>>> #给装饰器指定参数:此时 x="My Name Is :" y="LyShark"
>>> @lyshark("My Name Is :","LyShark")
def test():
print("我是test(),主函数，装饰器在装饰我")
>>> test()
主函数执行前,应先执行我！
My Name Is : LyShark
我是test(),主函数,装饰器在装饰我
主函数执行后,要执行我！
本文作者： 王瑞
本文链接： https://www.lyshark.com/post/63fd2e5b.html
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！