Python装饰器(fuctional decorators)就是用于拓展原来函数功能的一种函数,目的是在不改变原函数名(或类名)的情况下,给函数增加新的功能。
这个函数的特殊之处在于它的返回值也是一个函数,这个函数是内嵌“原" 函数的函数。
一般而言,我们要想拓展原来函数代码,最直接的办法就是侵入代码里面修改,例如:
import time
def f():
print("hello")
time.sleep(1)
print("world")
这是我们最原始的的一个函数,然后我们试图记录下这个函数执行的总时间,那最简单的做法就是改动原来的代码:
import time
def f():
start_time = time.time()
print("hello")
time.sleep(1)
print("world")
end_time = time.time()
execution_time = (end_time - start_time)*1000
print("time is %d ms" %execution_time)
但是实际工作中,有些时候核心代码并不可以直接去改,所以在不改动原代码的情况下,我们可以再定义一个函数。(但是生效需要再次执行函数)
import time
def deco(func):
start_time = time.time()
f()
end_time = time.time()
execution_time = (end_time - start_time)*1000
print("time is %d ms" %execution_time)
def f():
print("hello")
time.sleep(1)
print("world")
if __name__ == '__main__':
deco(f)
print("f.__name__ is",f.__name__)
print()
输出如下:
hello
world
time is 1000 ms
f.__name__ is f
这里我们定义了一个函数deco,它的参数是一个函数,然后给这个函数嵌入了计时功能。但是想要拓展这一千万个函数功能,
就是要执行一千万次deco()函数,所以这样并不理想!接下来,我们可以试着用装饰器来实现,先看看装饰器最原始的面貌。
import time
def deco(f):
def wrapper():
start_time = time.time()
f()
end_time = time.time()
execution_time = (end_time - start_time) * 1000
print("time is %d ms" % execution_time)
return wrapper
@deco
def f():
print("hello")
time.sleep(1)
print("world")
if __name__ == '__main__':
f()
输出如下:
hello
world
time is 1000 ms
这里的deco函数就是最原始的装饰器,它的参数是一个函数,然后返回值也是一个函数。
其中作为参数的这个函数f()就在返回函数wrapper()的内部执行。然后在函数f()前面加上@deco,
f()函数就相当于被注入了计时功能,现在只要调用f(),它就已经变身为“新的功能更多”的函数了,(不需要重复执行原函数)。
import time
def deco(f):
def wrapper(a,b):
start_time = time.time()
f(a,b)
end_time = time.time()
execution_time = (end_time - start_time)*1000
print("time is %d ms" % execution_time)
return wrapper
@deco
def f(a,b):
print("be on")
time.sleep(1)
print("result is %d" %(a+b))
if __name__ == '__main__':
f(3,4)
输出如下:
be on
result is 7
time is 1000 ms
import time
def deco(f):
def wrapper(*args, **kwargs):
start_time = time.time()
f(*args, **kwargs)
end_time = time.time()
execution_time = (end_time - start_time)*1000
print("time is %d ms" %execution_time)
return wrapper
@deco
def f(a,b):
print("be on")
time.sleep(1)
print("result is %d" %(a+b))
@deco
def f2(a,b,c):
print("be on")
time.sleep(1)
print("result is %d" %(a+b+c))
if __name__ == '__main__':
f2(3,4,5)
f(3,4)
输出如下:
be on
result is 12
time is 1000 ms
be on
result is 7
time is 1000 ms
import time
def deco01(f):
def wrapper(*args, **kwargs):
print("this is deco01")
start_time = time.time()
f(*args, **kwargs)
end_time = time.time()
execution_time = (end_time - start_time)*1000
print("time is %d ms" % execution_time)
print("deco01 end here")
return wrapper
def deco02(f):
def wrapper(*args, **kwargs):
print("this is deco02")
f(*args, **kwargs)
print("deco02 end here")
return wrapper
@deco01
@deco02
def f(a,b):
print("be on")
time.sleep(1)
print("result is %d" %(a+b))
if __name__ == '__main__':
f(3,4)
输出如下:
this is deco01
this is deco02
be on
result is 7
deco02 end here
time is 1009 ms
deco01 end here
装饰器调用顺序
装饰器是可以叠加使用的,那么使用装饰器以后代码是啥顺序呢?
对于Python中的”@”语法糖,装饰器的调用顺序与使用 @ 语法糖声明的顺序相反。
在这个例子中,f(3, 4) 等价于 deco01(deco02(f(3, 4)))。
在Python中有三个内置的装饰器,都是跟class相关的:staticmethod、classmethod 和property。
对于staticmethod和classmethod这里就不介绍了,通过一个例子看看property。
class Foo(object):
def __init__(self, var):
super(Foo, self).__init__()
self.__var = var
@property
def var(self):
return self.__var
@var.setter
def var(self, var):
self.__var = var
if __name__ == "__main__":
foo = Foo("var1")
print(foo.var)
foo.var = "var2"
print(foo.var)
注意,对于Python新式类(在 py3 里面的继承 object 的类(默认),以及它的子类都是新式类),如果将上面的 “@var.setter” 装饰器所装饰的成员函数去掉,则Foo.var 属性为只读属性,使用 “foo.var = ‘var 2′” 进行赋值时会抛出异常。但是,对于Python classic class,所声明的属性不是 read-only的,所以即使去掉”@var.setter”装饰器也不会报错。
在实际代码中可能需要使用参数化的装饰器。如果用函数作为装饰器的话,那么解决方法很简单:再增加一层包装。例如:
def repeat(number=3):
"""多次重复执行原始函数,返回最后一次调用的值作为结果"""
def actual_decorator(function):
def wrapper(*args, **kwargs):
result = None
for i in range(number):
result = function(*args, **kwargs)
return result
return wrapper
return actual_decorator
@repeat() # 即使有默认参数,这里的括号也不能省略
def f():
print("喵")
@repeat(2)
def g(a,b):
print("g函数执行中")
return a + b
if __name__ == "__main__":
f()
print()
print(g(1, 2))
def dumy_dec(function):
def wrapped(*args, **kwargs):
"""包装函数内部文档"""
return function(*args, **kwargs)
return wrapped
@dumy_dec
def function():
"""原始的文档字符串"""
if __name__ == "__main__":
print(function.__name__)
print(function.__doc__)
使用装饰器后,我们如果想查看原始函数的函数名或原始函数的文档字符串,返回的却是:
wrapped
包装函数内部文档
解决这个问题的正确办法,是使用functools模块内置的wraps()装饰器。
from functools import wraps
def preserving_dec(function):
@wraps(function) # 注意看这里!
def wrapped(*args, **kwargs):
"""包装函数内部文档"""
return function(*args, **kwargs)
return wrapped
@preserving_dec
def function():
"""原始的文档字符串"""
if __name__ == "__main__":
print(function.__name__)
print(function.__doc__)
结果如下:
function
原始的文档字符串
装饰器函数其实是这样一个接口约束,它必须接受一个callable对象作为参数,然后返回一个callable对象。在Python中一般callable对象都是函数,但也有例外。只要某个对象重载了__call__()方法,那么这个对象就是callable的。由此使用用户自定义的类也可以实现装饰器:
class Decorator:
def __init__(self, function):
self.function = function
def __call__(self, *args, **kwargs):
print("Do something here before call The original function")
print(self.function.__doc__)
result = self.function(*args, **kwargs)
print("Do something here after call The original function")
return result
@Decorator
def add(a, b):
"""原始函数的文档字符串"""
print("The original function is running")
return a + b
if __name__ == "__main__":
add(1, 2)
结果如下:
Do something here before call The original function
原始函数的文档字符串
The original function is running
Do something here after call The original function
from datetime import datetime
def logging(func):
def wrapper(*args, **kwargs):
"""print log before a function."""
print("[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__))
return func(*args, **kwargs)
return wrapper
class Car(object):
def __init__(self, model):
self.model = model
@logging # 装饰实例方法,OK
def run(self):
print(f"{self.model} is running!")
@logging # 装饰静态方法,Failed
@staticmethod
def check_model_for(obj):
if isinstance(obj, Car):
print(f"The model of your car is {obj.model}")
else:
print(f"{obj} is not a car!")
car = Car("麒麟")
car.run()
Car.check_model_for(car)
会报错:
Traceback (most recent call last):
File "F:/AutoOps_platform/装饰器.py", line 253, in <module>
Car.check_model_for(car)
File "F:/AutoOps_platform/装饰器.py", line 231, in wrapper
print("[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__))
AttributeError: 'staticmethod' object has no attribute '__name__'
[DEBUG] 2021-08-06 13:11:19.070195: enter run()
麒麟 is running!
@staticmethod 这个装饰器,其实返回的并不是一个callable对象,而是一个staticmethod 对象,那么它是不符合装饰器要求的(比如传入一个callable对象),你自然不能在它之上再加别的装饰器。要解决这个问题很简单,只要把你的装饰器放在@staticmethod 之前就好了:
@staticmethod
@logging # 先装饰就没问题
def check_model_for(obj):
if isinstance(obj, Car):
print(f"The model of your car is {obj.model}")
else:
print(f"{obj} is not a car!")
[DEBUG] 2021-08-06 13:14:40.404121: enter run()
麒麟 is running!
[DEBUG] 2021-08-06 13:14:40.404121: enter check_model_for()
The model of your car is 麒麟
decorator.py 是一个非常简单的装饰器加强包。你可以很直观的先定义包装函数wrapper(),再使用decorate(func, wrapper)方法就可以完成一个装饰器。
from decorator import decorate
from datetime import datetime
def wrapper(func, *args, **kwargs):
"""print log before a function."""
print("[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__))
return func(*args, **kwargs)
def logging(func):
return decorate(func, wrapper) # 用wrapper装饰func
@logging
def f(a, b):
return a + b
f(1,2)
你也可以使用它自带的@decorator装饰器来完成你的装饰器。
from decorator import decorator
from datetime import datetime
@decorator
def logging(func, *args, **kwargs):
print(f"[DEBUG] {datetime.now()}: enter {func.__name__}()")
return func(*args, **kwargs)
@logging
def f(a, b):
return a + b
f(1,2)
[DEBUG] 2021-08-06 13:19:44.920748: enter f()
decorator.py实现的装饰器能完整保留原函数的name,doc和args。
也可以使用第三方库wrapt:
import wrapt
@wrapt.decorator # without argument in decorator
def logging(wrapped, instance, args, kwargs): # instance is must
print(f"[DEBUG]: enter {wrapped.__name__}()")
return wrapped(*args, **kwargs)
@logging
def say(something):
print(f"is saying {something}")
say("喵")
[DEBUG]: enter say()
is saying 喵
使用wrapt你只需要定义一个装饰器函数,但是函数签名是固定的,必须是(wrapped, instance, args, kwargs),注意第二个参数instance是必须的,就算你不用它。当装饰器装饰在不同位置时它将得到不同的值,比如装饰在类实例方法时你可以拿到这个类实例。根据instance的值你能够更加灵活的调整你的装饰器。另外,args和kwargs也是固定的,注意前面没有星号。在装饰器内部调用原函数时才带星号。
如果你需要使用wrapt写一个带参数的装饰器,可以这样写:
def logging(level):
@wrapt.decorator
def wrapper(wrapped, instance, args, kwargs):
print("[{}]: enter {}()".format(level, wrapped.__name__))
return wrapped(*args, **kwargs)
return wrapper
@logging(level="INFO")
def say(something):
print(f"is saying {something}")
say("喵")
[INFO]: enter say()
is saying 喵
总结:
本文介绍了Python装饰器的一些使用,装饰器的代码还是比较容易理解的。只要通过一些例子进行实际操作一下,就很容易理解了。
本文分享自 Python数据分析实例 微信公众号,前往查看
如有侵权,请联系 cloudcommunity@tencent.com 删除。
本文参与 腾讯云自媒体同步曝光计划 ,欢迎热爱写作的你一起参与!