Python函数装饰器原理与用法详解

本⽂实例讲述了Python函数装饰器原理与⽤法。分享给⼤家供⼤家参考，具体如下：

装饰器本质上是⼀个函数，该函数⽤来处理其他函数，它可以让其他函数在不需要修改代码的前提下增加额外的功能，装饰器的返回值也是⼀个函数对象。它经常⽤于有切⾯需求的场景，⽐如：插⼊⽇志、性能测试、事务处理、缓存、权限校验等应⽤场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出⼤量与函数功能本⾝⽆关的雷同代码并继续重⽤。概括的讲，装饰器的作⽤就是为已经存在的对象添加额外的功能。

严格来说，装饰器只是语法糖，装饰器是可调⽤的对象，可以像常规的可调⽤对象那样调⽤，特殊的地⽅是装饰器的参数是⼀个函数

现在有⼀个新的需求，希望可以记录下函数的执⾏时间，于是在代码中添加⽇志代码：

import time

#遵守开放封闭原则def foo():

start = time.time()

# print(start) # 1504698634.0291758从1970年1⽉1号到现在的秒数，那年Unix诞⽣ time.sleep(3) end = time.time()

print('spend %s'%(end - start))foo()

bar()、bar2()也有类似的需求，怎么做？再在bar函数⾥调⽤时间函数？这样就造成⼤量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义⼀个函数：专门设定时间:

import time

def show_time(func): start_time=time.time() func()

end_time=time.time()

print('spend %s'%(end_time-start_time))def foo():

print('hello foo') time.sleep(3)show_time(foo)

但是这样的话,你基础平台的函数修改了名字，容易被业务线的⼈投诉的，因为我们每次都要将⼀个函数作为参数传递给

show_time函数。⽽且这种⽅式已经破坏了原有的代码逻辑结构，之前执⾏业务逻辑时，执⾏运⾏foo()，但是现在不得不改成show_time(foo)。那么有没有更好的⽅式的呢？当然有，答案就是装饰器。

def show_time(f): def inner():

start = time.time() f()

end = time.time()

print('spend %s'%(end - start)) return inner

@show_time #foo=show_time(f)def foo(): print('foo...') time.sleep(1)foo()def bar(): print('bar...') time.sleep(2)bar()

输出结果：

foo...

spend 1.0005607604980469bar...

函数show_time就是装饰器，它把真正的业务⽅法f包裹在函数⾥⾯，看起来像foo被上下时间函数装饰了。在这个例⼦中，函数进⼊和退出时 ，被称为⼀个横切⾯(Aspect)，这种编程⽅式被称为⾯向切⾯的编程(Aspect-Oriented Programming)。

@符号是装饰器的语法糖，在定义函数的时候使⽤，避免再⼀次赋值操作

装饰器在Python使⽤如此⽅便都要归因于Python的函数能像普通的对象⼀样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外⼀个函数内。

装饰器有２个特性，⼀是可以把被装饰的函数替换成其他函数，　⼆是可以在加载模块时候⽴即执⾏

def decorate(func):

print('running decorate', func) def decorate_inner():

print('running decorate_inner function') return func()

return decorate_inner@decoratedef func_1():

print('running func_1')

if __name__ == '__main__': print(func_1)

#running decorate

# .decorate_inner at 0x000001904743DF28> func_1()

#running decorate_inner function # running func_1

通过args 和　*kwargs 传递被修饰函数中的参数

def decorate(func):

def decorate_inner(*args, **kwargs): print(type(args), type(kwargs)) print('args', args, 'kwargs', kwargs) return func(*args, **kwargs) return decorate_inner@decorate

def func_1(*args, **kwargs): print(args, kwargs)

if __name__ == '__main__':

func_1('1', '2', '3', para_1='1', para_2='2', para_3='3')#返回结果

#

# args ('1', '2', '3') kwargs {'para_1': '1', 'para_2': '2', 'para_3': '3'}# ('1', '2', '3') {'para_1': '1', 'para_2': '2', 'para_3': '3'}

带参数的被装饰函数　

import time# 定长

def show_time(f): def inner(x,y):

start = time.time() f(x,y)

end = time.time()

print('spend %s'%(end - start)) return inner@show_timedef add(a,b): print(a+b) time.sleep(1)add(1,2)

不定长

import time#不定长

def show_time(f): def inner(*x,**y): start = time.time() f(*x,**y)

end = time.time()

print('spend %s'%(end - start)) return inner@show_timedef add(*a,**b):

sum=0 for i in a: sum+=i print(sum) time.sleep(1)add(1,2,3,4)

带参数的装饰器

在上⾯的装饰器调⽤中，⽐如@show_time，该装饰器唯⼀的参数就是执⾏业务的函数。装饰器的语法允许我们在调⽤时，提供其它参数，⽐如@decorator(a)。这样，就为装饰器的编写和使⽤提供了更⼤的灵活性。

import time

def time_logger(flag=0): def show_time(func):

def wrapper(*args, **kwargs): start_time = time.time() func(*args, **kwargs) end_time = time.time()

print('spend %s' % (end_time - start_time)) if flag:

print('将这个操作的时间记录到⽇志中') return wrapper return show_time@time_logger(flag=1)def add(*args, **kwargs): time.sleep(1) sum = 0 for i in args: sum += i print(sum)add(1, 2, 5)

@time_logger(flag=1) 做了两件事：

（1）time_logger(1)：得到闭包函数show_time，⾥⾯保存环境变量flag（2）@show_time ：add＝show_time(add)

上⾯的time_logger是允许带参数的装饰器。它实际上是对原有装饰器的⼀个函数封装，并返回⼀个装饰器(⼀个含有参数的闭包函数)。当我 们使⽤@time_logger(1)调⽤的时候，Python能够发现这⼀层的封装，并把参数传递到装饰器的环境中。叠放装饰器执⾏顺序是什么

如果⼀个函数被多个装饰器修饰，其实应该是该函数先被最⾥⾯的装饰器修饰后（下⾯例⼦中函数main()先被inner装饰，变成新的函数），变成另⼀个函数后，再次被装饰器修饰

def outer(func):

print('enter outer', func) def wrapper():

print('running outer') func()

return wrapperdef inner(func):

print('enter inner', func) def wrapper():

print('running inner') func()

return wrapper@outer@innerdef main():

print('running main')

if __name__ == '__main__': main()#返回结果

# enter inner

# enter outer .wrapper at 0x000001A9F2BD5048># running outer# running inner

# running main

类装饰器

相⽐函数装饰器，类装饰器具有灵活度⼤、⾼内聚、封装性等优点。使⽤类装饰器还可以依靠类内部的__call__⽅法，当使⽤@ 形式将装饰器附加到函数上时，就会调⽤此⽅法。

import time

class Foo(object):

def __init__(self, func): self._func = func def __call__(self):

start_time=time.time() self._func()

end_time=time.time()

print('spend %s'%(end_time-start_time))@Foo #bar=Foo(bar)def bar(): print ('bar') time.sleep(2)

bar() #bar=Foo(bar)()>>>>>>>没有嵌套关系了,直接active Foo的 __call__⽅法

标准库中有多种装饰器

例如：装饰⽅法的函数有property, classmethod, staticmethod；　functools模块中的lru_cache, singledispatch, wraps 等等

from functools import lru_cache

from functools import singledispatchfrom functools import wraps

functools.wraps使⽤装饰器极⼤地复⽤了代码，但是他有⼀个缺点就是原函数的元信息不见了，⽐如函数的docstring、__name__、参数列表，先看例⼦：

def foo():

print(\"hello foo\")

print(foo.__name__)# foodef logged(func):

def wrapper(*args, **kwargs):

print (func.__name__ + \" was called\") return func(*args, **kwargs) return wrapper@loggeddef cal(x):

resul=x + x * x print(resul)cal(2)#6

#cal was called

print(cal.__name__)# wrapperprint(cal.__doc__)#None

#函数f被wrapper取代了，当然它的docstring，__name__就是变成了wrapper函数的信息了。

好在我们有functools.wraps，wraps本⾝也是⼀个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数⼀样的元信息了。

from functools import wrapsdef logged(func): @wraps(func)

def wrapper(*args, **kwargs):

print(func.__name__ + \" was called\") return func(*args, **kwargs) return wrapper@loggeddef cal(x):

return x + x * x

print(cal.__name__) # cal

使⽤装饰器会产⽣我们可能不希望出现的副作⽤，　例如：改变被修饰函数名称，对于调试器或者对象序列化器等需要使⽤内省机制的那些⼯具，可能会⽆法正常运⾏；

其实调⽤装饰器后，会将同⼀个作⽤域中原来函数同名的那个变量（例如下⾯的func_1）,重新赋值为装饰器返回的对象；使⽤＠wraps后，会把与内部函数（被修饰函数，例如下⾯的func_1）相关的重要元数据全部复制到外围函数（例如下⾯的decorate_inner）

from functools import wrapsdef decorate(func):

print('running decorate', func) @wraps(func)

def decorate_inner():

print('running decorate_inner function', decorate_inner) return func()

return decorate_inner@decoratedef func_1():

print('running func_1', func_1)if __name__ == '__main__': func_1()#输出结果

#running decorate

# running decorate_inner function # running func_1

关于Python相关内容感兴趣的读者可查看本站专题：《》、《》、《》、《》、《》及《》希望本⽂所述对⼤家Python程序设计有所帮助。