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方法里面可以套方法，那么，我们可以装饰我们需要的方法。
import time def decorate(func):
def function():
start = time.time()
func()
end = time.time()
print "运行时间是：{}".format(end - start)
function() def test1():
print "hello"
print test1.__name__ def test2():
print "hello"
print test1.__name__ decorate(test1)
decorate(test2) 执行结果：
首先，我们要的方法是一定要执行的，只是执行的方式变了，而是把它封装在了另一个方法中，将方法名字作为参数，传给封装的方法（decorate），在我们的方法（func）前后，填入我们想实现的功能的语句（start = time.time()， end = time.time()，print "运行时间是：{}".format(end - start)），这只是实现了方法封装的思路，具体还不是这样子写。
首先，对原函数做了包装并返回了另外一个函数，额外添加了一些功能.
代码的改写，首选用@语法糖，将装饰器名字写在方法上面，装饰器内部需要返回方法，而不是直接执行方法，这是最简单的装饰器。
import time
def decorate(func):
def function():
start = time.time()
func()
end = time.time()
print "运行时间是：{}".format(end - start)
return function def hello(func):
start = time.time()
func()
end = time.time()
print "运行时间是：{}".format(end - start) @decorate
def test1():
print "hello"
print test1.__name__ @decorate
def test2():
print "hello"
print test2.__name__ test1()
test2()
但是有一个问题，如果被装饰的函数需要传入参数，那么这个装饰器就坏了。因为返回的函数并不能接受参数，你可以指定装饰器函数function接受和原函数一样的参数，比如：
import time def decorate(func):
def function(a,b):
start = time.time()
func(a,b)
end = time.time()
print "运行时间是：{}".format(end - start)
return function @decorate
def test2(a,b):
print "hello",a+b test2(3,7)
所以有一个问题，如果有的方法没有参数，有的方法有参数，有的方法参数数量不一致，类型不一致，难道要写很多个装饰器吗？python的语法很好的解决了这一个问题，那就是参数的处理，参数随着函数自已选择是不是有参。
import time def hello(func):
start = time.time()
func()
end = time.time()
print "运行时间是：{}".format(end - start) def decorate(func):
def function(*args,**kwargs):
print func.__name__
start = time.time()
func(*args,**kwargs)
end = time.time()
print "运行时间是：{}".format(end - start)
return function @decorate
def test1():
print "hello" @decorate
def test2(a,b):
print "hello",a+b test2(3,7)
test1() 运行结果：
更高级的装饰器：带参数的装饰器
import time def logging(level):
def decorate(func):
def function(*args, **kwargs):
print func.__name__,level
start = time.time()
func(*args, **kwargs)
end = time.time()
print "运行时间是：{}".format(end - start)
return function
return decorate @logging(level='INFO') #等价于 logging(level='INFO')(test3)
def test3():
pass test3() 运行结果：
类构造器：要了解类构造器，首先要了解__call__这个函数
__call__()
Python中的函数是一级对象。这意味着Python中的函数的引用可以作为输入传递到其他的函数/方法中，并在其中被执行。
而Python中类的实例（对象）可以被当做函数对待。也就是说，我们可以将它们作为输入传递到其他的函数/方法中并调用他们，正如我们调用一个正常的函数那样。而类中__call__()函数的意义正在于此。为了将一个类实例当做函数调用，我们需要在类中实现__call__()方法。也就是我们要在类中实现如下方法：def __call__(self, *args)。这个方法接受一定数量的变量作为输入。
假设a是Class类的一个实例。那么调用a.__call__()等同于调用a()。这个实例本身在这里相当于一个函数。
比如：
class Class(object):
def __call__(self, *args, **kwargs):
print "aa"
a=Class()
a()
执行结果：
aa
我们可以让类的构造函数__init__()接受一个函数，然后重载__call__()并返回一个函数，也可以达到装饰器函数的效果。
class Class(object):
def __init__(self,func):
self.func = func
def __call__(self, *args, **kwargs):
print "start"
self.func(*args, **kwargs)
print "end"
@Class def Ctest(something): print "say",something Ctest("love")
执行结果：
start
say love
end
带参数的类装饰器：
class Class(object):
def __init__(self,level):
self.level = level
def __call__(self, func): #接受函数
def wrapper(*args, **kwargs):
print "start"
func(*args, **kwargs)
print "end"
return wrapper #返回函数
@Class(level="INFO")
def Ctest(something):
print "say",something
Ctest("love")
执行结果：
start
say love
end