import time
def test1():
print "hello\n"
print test1.__name__
def test2():
print "hello\n"
print test2.__name__
start = time.time()
test1()
end =time.time()
print "运行时间是:{}".format(end-start)
start = time.time()
test2()
end = time.time()
print "运行时间是:{}".format(end-start)
运行结果:
如上两段代码,我想计算方法的运行时间,这样写两次代码有点繁琐,而且观察每段代码都有重复的语句,print "hello\n",和后面的打印名字,那么,我们怎么写可以去掉方法冗余的代码?那么,就来介绍装饰器,首先,装饰器是在不改变源代码的基础上可以增加方法的功能。
首先python方法里面可以套方法,那么,我们可以装饰我们需要的方法。
importtimedefdecorate(func):deffunction():
start=time.time()
func()
end=time.time()print "运行时间是:{}".format(end -start)
function()deftest1():print "hello"
print test1.__name__
deftest2():print "hello"
print test1.__name__decorate(test1)
decorate(test2)
执行结果:
首先,我们要的方法是一定要执行的,只是执行的方式变了,而是把它封装在了另一个方法中,将方法名字作为参数,传给封装的方法(decorate),在我们的方法(func)前后,填入我们想实现的功能的语句(start = time.time(), end = time.time(),print "运行时间是:{}".format(end - start)),这只是实现了方法封装的思路,具体还不是这样子写。
首先,对原函数做了包装并返回了另外一个函数,额外添加了一些功能.
代码的改写,首选用@语法糖,将装饰器名字写在方法上面,装饰器内部需要返回方法,而不是直接执行方法,这是最简单的装饰器。
import time
defdecorate(func):deffunction():
start=time.time()
func()
end=time.time()print "运行时间是:{}".format(end -start)returnfunctiondefhello(func):
start=time.time()
func()
end=time.time()print "运行时间是:{}".format(end -start)
@decoratedeftest1():print "hello"
print test1.__name__@decoratedeftest2():print "hello"
print test2.__name__test1()
test2()
但是有一个问题,如果被装饰的函数需要传入参数,那么这个装饰器就坏了。因为返回的函数并不能接受参数,你可以指定装饰器函数function接受和原函数一样的参数,比如:
importtimedefdecorate(func):deffunction(a,b):
start=time.time()
func(a,b)
end=time.time()print "运行时间是:{}".format(end -start)returnfunction
@decoratedeftest2(a,b):print "hello",a+b
test2(3,7)
所以有一个问题,如果有的方法没有参数,有的方法有参数,有的方法参数数量不一致,类型不一致,难道要写很多个装饰器吗?python的语法很好的解决了这一个问题,那就是参数的处理,参数随着函数自已选择是不是有参。
importtimedefhello(func):
start=time.time()
func()
end=time.time()print "运行时间是:{}".format(end -start)defdecorate(func):def function(*args,**kwargs):print func.__name__start=time.time()
func(*args,**kwargs)
end=time.time()print "运行时间是:{}".format(end -start)returnfunction
@decoratedeftest1():print "hello"@decoratedeftest2(a,b):print "hello",a+b
test2(3,7)
test1()
运行结果:
更高级的装饰器:带参数的装饰器
importtimedeflogging(level):defdecorate(func):def function(*args, **kwargs):print func.__name__,level
start=time.time()
func(*args, **kwargs)
end=time.time()print "运行时间是:{}".format(end -start)returnfunctionreturndecorate
@logging(level='INFO') #等价于 logging(level='INFO')(test3)
deftest3():passtest3()
运行结果:
类构造器:要了解类构造器,首先要了解__call__这个函数
__call__()
Python中的函数是一级对象。这意味着Python中的函数的引用可以作为输入传递到其他的函数/方法中,并在其中被执行。
而Python中类的实例(对象)可以被当做函数对待。也就是说,我们可以将它们作为输入传递到其他的函数/方法中并调用他们,正如我们调用一个正常的函数那样。而类中__call__()函数的意义正在于此。为了将一个类实例当做函数调用,我们需要在类中实现__call__()方法。也就是我们要在类中实现如下方法:def __call__(self, *args)。这个方法接受一定数量的变量作为输入。
假设a是Class类的一个实例。那么调用a.__call__()等同于调用a()。这个实例本身在这里相当于一个函数。
比如:
classClass(object):def __call__(self, *args, **kwargs):print "aa"a=Class()
a()
执行结果:
aa
我们可以让类的构造函数__init__()接受一个函数,然后重载__call__()并返回一个函数,也可以达到装饰器函数的效果。
classClass(object):def __init__(self,func):
self.func=funcdef __call__(self, *args, **kwargs):print "start"
self.func(*args, **kwargs)print "end"
@ClassdefCtest(something):print "say",something Ctest("love")
执行结果:
start
say love
end
带参数的类装饰器:
classClass(object):def __init__(self,level):
self.level=leveldef __call__(self, func): #接受函数
def wrapper(*args, **kwargs):print "start"func(*args, **kwargs)print "end"
return wrapper #返回函数
@Class(level="INFO")defCtest(something):print "say",something
Ctest("love")
执行结果:
start
say love
end