python带参数的装饰器

装饰器更高级的用法是可以带参数。

带参数的装饰器

先来看一个不带参数的装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import time


def timeit(fn):
def wrap(*args,**kwargs):
start = time.time()
ret = fn(*args,**kwargs)
print(time.time() - start)
return ret
return wrap

@timeit
def sleep(x):
time.sleep(x)
1
sleep(3)
3.0034420490264893

这里打印出来的是执行sleep函数所消耗的自然时间,但在执行此函数时所消耗的cpu时间真的有3.0034420490264893秒吗?当然不是。利用time包中的time.clock方法可以计算得到代码执行所消耗cpu的时间,那怎样来修改上边的timeit函数,让其即能计算代码执行的自然时间,也能计算代码执行所消耗cpu的时间?做如下改进:

1
2
3
4
5
6
7
8
9
10
11
12
13
def timeit_1(process_time=False):
cacl = time.clock if process_time else time.time
def timeit_2(fn):
def wrap(*args,**kwargs):
start = cacl()
ret = fn(*args,**kwargs)
print(cacl() - start)
return ret
return wrap
return timeit_2

def sleep_1(x):
time.sleep(x)
1
timeit_1(True)(sleep_1)(3)
0.020000000000000018
1
timeit_1(False)(sleep_1)(3)
3.0038363933563232
1
timeit_1()(sleep_1)(3)   # 参数process_time是一个默认参数,所以可以不传递值,默认为False
3.003509283065796

上边的调用过程是怎样的呢?分解一下,如下:

1
fn1 = timeit_1(True)

上边调用timeit_1(True),函数return回了timeit_2,并把fn1这个变量指向了调用结果,即指向了timeit_2,这里的timeit_2也是一个函数,此函数接收一个参数

1
fn2 = fn1(sleep_1)

这里调用fn1(sleep_1),其实就是调用了timeit_2(sleep_1),并把fn2这个变量指向了调用后的结果,即指向了warp,这里的warp也是一个函数,此函数能接收任意的参数

1
fn2(3)
0.009999999999999787

上边调用fn2(3),其实是调用了wrap(3),即执行了wrap函数内的语句,此函数内的ret = fn(*args,**kwargs)语句中的fn其实是指向了sleep,所以在执行wrap函数时,sleep_1函数才真正被执行。

既然装饰器可以用魔法来装饰一个函数,那上边经过改进过的装饰器是不是也能装饰一个函数呢?如下:

1
2
3
@timeit_1(False)
def sleep_2(x):
time.sleep(x)
1
sleep_2(3)
3.0039477348327637

如果想计算代码执行的cpu时间,那如下即可:

1
2
3
@timeit_1(True)
def sleep_3(x):
time.sleep(x)
1
sleep_3(3)
0.0

这个魔法又发生了什么呢?

其实质就是在没有用魔法的情况下直接timeit_1(True)(sleep_3)(3)。而当使用@这个魔法后,当代码执行到此行时,解析器会执行timeit_1(True),timeit_1实质就是一函数,接收一个参数,并返回一个timeit_2函数。当代码执行到@所在语句时,会把所装饰的sleep_3函数作为一个参数传递给timeit_1(True)的调用结果,即timeit_2这个函数,即sleep_3这个函数已作为一个变量传递给了timeit_2(fn)中的fn参数,并返回了一个wrap函数,在接下的调用sleep_3(3)这个操作,其实此时的sleep_3这个函数已不是原先的def sleep_3(x):中的sleep_3函数,而是一个指向了wrap的函数,wrap函数接收任何参数,所以把当执行sleep_3(3)时,把参数3传递给了wrap函数,并执行内部的代码,内部代码中ret = fn(*args,**kwargs)中的fn函数依赖还是指向原先的sleep_3(x)这个函数。

这里也有一个简单的记忆方式,如果一个函数被装饰器所装饰,在调用这个函数时其实不再是调用表面上看上去的这个函数,以

1
2
3
@timeit_1(True)
def sleep_3(x):
time.sleep(x)

来做说明。当执行到有@魔法所在行时,相当于执行了sleep_3 = timeit_1(True)(sleep_3),即指向了wrap函数,既然sleep_3指向了wrap函数,那我们执行sleep_3(3)时,其实就是在进行wrap(3)这样的函数调用,记住,函数名也是一个变量。

再来举一个带参数的装饰器的例子,比如有一个函数,只有在对有许可权限的用户开放,执行此函数的用户没有在认证列表里的,就不会执行这个函数。这个该如何实现呢?如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def check(allow_users):
def inner_check(fn):
def wrap(username,*args,**kwargs):
'''This is wrap'''
if username in allow_users:
return fn(username,*args,**kwargs)
return "You are illegal users"
return wrap
return inner_check

@check(['zhaochj','zcj'])
def private(username):
'''The authentication'''
return "You are legitimate users"
1
private('zhaochj')
'You are legitimate users'
1
private('tom')
'You are illegal users'

这样就可以对调用函数进行身份验证。

python中一个函数有一些属性是函数本身具有的,比如__name__属性是查看函数名称,__doc__是查看函数文档的等等。如果一个函数被装饰器装饰过后,这个函数的这些属性会发生怎样的变化呢?以上边的check装饰器和private函数为例子,如下:

1
private.__name__
'wrap'
1
private.__doc__
'This is wrap'

private函数的名称是wrap了,文档也是wrap函数的文档,这是怎么回事?上边已经说过,这里的private函数被装饰器装饰后它已不再是原来的private函数,private这个函数名称会被指向到wrap这个函数对象,那当然用上边的private.__name__private.__doc__查看函数的属性就会是wrap函数的属性。那怎样来修正呢?可以这样做,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def check_1(allow_users):
def inner_check(fn):
def wrap(username,*args,**kwargs):
'''This is wrap'''
if username in allow_users:
return fn(username,*args,**kwargs)
return "You are illegal users"
wrap.__name__ = fn.__name__
wrap.__doc__ = fn.__doc__
return wrap
return inner_check


@check_1(['zhaochj','zcj'])
def private_1(username):
'''The authentication'''
return "You are legitimate users"
1
private_1.__name__
'private_1'
1
private_1.__doc__
'The authentication'

通过在装饰器把__name____doc__重新赋值后就能更正这个问题,但对一个函数来说像__name__这样类似的属性有许多,如果都是这样手工来修正显然是不现实的,所以python提供了一个wraps装饰器来自动修正这个问题,wrapsfunctools这个包中,所以可以这样来修正这个问题,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import functools

def check_1(allow_users):
def inner_check(fn):
@functools.wraps(fn)
def wrap(username,*args,**kwargs):
'''This is wrap'''
if username in allow_users:
return fn(username,*args,**kwargs)
return "You are illegal users"
return wrap
return inner_check


@check_1(['zhaochj','zcj'])
def private_1(username):
'''The authentication'''
return "You are legitimate users"
1
private_1.__name__
'private_1'
1
private_1.__doc__
'The authentication'

@functools.wraps(fn)这个装饰器相当于执行了wrap.__name__ = fn.__name__这样的操作。

文章目录
  1. 1. 带参数的装饰器
|