Python无参装饰器的实现方案及优化

一、什么是装饰器

定义一个函数，该函数可为其他函数添加额外的功能。

二、何时用装饰器

需要在不修改被装饰对象源代码及其调用方式时，为被装饰对象添加额外的功能。

三、如何写一个装饰器

现在我们有如下一个函数help（），time.sleep（）来模拟函数执行时间，print打印传入参数值，方便我们来进行分析。如果现在我们需要为help函数添加一个统计其运行时间的功能，我们可以怎么做？

import time
 
def help(x, y):
    time.sleep(1)
    print(f'x={x} y={y}')
 
help(1, 2)

方案一：

在help函数开头结束分别调用time.time（），两者相减得运行时间。

import time
 
def help(x, y):
    start = time.time()
    time.sleep(1)
    print(f'x={x} y={y}')
    stop = time.time()
    print(stop - start)
 
help(1, 2)

运行结果：

方案一中我们在help中加了相关代码，虽然没有改变它的调用方式，但改变了它的源代码。我们继续想想如何两者都不改变的情况下，完成我们的目标。

对，函数内不能动，我们可以动函数外呀，在help前后加上相关代码，似乎就可以达到我们的目标了，这就是方案二，我们来试试。

方案二：

import time
 
def help(x, y):
    time.sleep(1)
    print(f'x={x} y={y}')
 
start = time.time()
help(1, 2)
stop = time.time()
print(stop - start)

运行结果：

显而易见，似乎没有问题，但是如果我们需要多次调用help函数的话，在它前后都得加上相同的代码，这样代码就会显得十分冗余了。既然help函数前后代码不会变的话，我们可以将它们封装成另一个函数呀，说干就干。

方案三：

import time
 
def help(x, y):
    time.sleep(1)
    print(f'x={x} y={y}')
 
def wrapper():
    start = time.time()
    help(1, 2)
    stop = time.time()
    print(stop - start)
 
wrapper()

运行一下：

 

这样我们就解决了多次调用的问题，但美中不足的是，help函数的调用方式改变了，而且help的参数固定，也只能修饰help函数，我们来一步步试着优化。

优化一（参数优化，实现任意参数）： 

对参数优化，我们可以将help的实参通过wrapper的传入，而为了实现任意参数，我们首先想的便是*args,**kwargs来作为函数的参数，于是将方案三进行改进如下（为方便分析，为help多增加了一个参数）：

import time
 
 
def help(x, y, z):
    time.sleep(1)
    print(f'x={x} y={y} z={z}')
 
 
def wrapper(*args, **kwargs):
    start = time.time()
    help(*args, **kwargs)
    stop = time.time()
    print(stop - start)
 
 
wrapper(1, 2, 3)

运行一下：

这样我们便将help的参数变得更加灵活了，接着我们来优化。

优化二（实现装饰其他对象）：

需要装饰其他对象，意味着我们在help位置的应该是一个可变参数，也就是用户输入的参数，即wapper函数内应变为：

def wrapper(*args, **kwargs):
    start = time.time()
    func(*args, **kwargs)
    stop = time.time()
    print(stop - start)

但是我们期望wrapper能和内部调用的func函数的参数一致，即wrapper的参数我们应该不去改变，那我们func的值从何处传来呢？

没错，我们可以运用闭包函数来传参，修改一下下：

def outter(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        func(*args, **kwargs)
        stop = time.time()
        print(stop - start)
 
    return wrapper

这样我们为其他函数修饰时，只需要将其函数名作为outter函数的参数传入即可：

import time
 
def help(x, y, z):
    time.sleep(1)
    print(f'这是help的{x}{y}{z}')
 
def others(x, y, z):
    time.sleep(1)
    print(f'这是others的{x}{y}{z}')
 
def outter(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        func(*args, **kwargs)
        stop = time.time()
        print(stop - start)
 
    return wrapper
 
help = outter(help)
others = outter(others)
 
help(1, 2, 3)
others(4, 5, 6)

运行一下：

结果符合预期，而且在使用时由于outter内的func是在局部名称空间，outter外的func是在全局名称空间，调用时二者并不冲突，并且使用时可读性较高，我们好像达成开始的目标，似乎能以假乱真了。但我们继续思考一下，我们演示用到的函数十分简单，甚至没有返回值，如果加上返回值后，我们再对其修饰后，能得到原函数的返回值吗？

优化三（得到相同返回值）：

回到我们的wrapper中去，既然需要我们func函数的返回值，我们直接将其赋值给res，再return出res的值：

import time
 
def help(x, y, z):
    time.sleep(1)
    print(f'这是help的{x}{y}{z}')
    return 'help'
 
def others(x, y, z):
    time.sleep(1)
    print(f'这是others的{x}{y}{z}')
    return 'others'
 
def outter(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        res=func(*args, **kwargs)
        stop = time.time()
        print(stop - start)
        return res
    return wrapper
 
help = outter(help)
others = outter(others)
 
res1=help(1, 2, 3)
res2=others(4, 5, 6)
print(res1,res2)

没毛病，跑一下：

 总结： 

到这我们完成了一个简单的无参装饰器，装饰后的func既没有改变源代码，也没有改变调用方式。

但是代码稍显冗余，python语法便规定：在被装饰对象正上方单独一行写@装饰器名字，等价于func=outter(func)，简化代码。从中我们总结出无参装饰器的一个模板：

def outter(func):
     def wrapper(*args,**kwargs):
         # 1、调用原函数
         # 2、增加的新功能
         res=func(*args,**kwargs)
         return res
     return wrapper
 
#使用时
@outter
def func:
    pass

到此这篇关于python无参装饰器的文章就介绍到这了,更多相关python无参装饰器内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！