python 装饰器的应用

import time

def test1():
　　print "hello
"
　　print test1.__name__

def test2():
　　print "hello
"
　　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 "，和后面的打印名字，那么，我们怎么写可以去掉方法冗余的代码？那么，就来介绍装饰器，首先，装饰器是在不改变源代码的基础上可以增加方法的功能。

首先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