@log

要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：

def log(f):
    def fn(*args, **kw):
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn

现在，对于任意函数，@log 都能正常工作。

---

@performance

import time

def performance(f):
    time.clock()
    def costtime(*args, **kargs):
        return f(*args, **kargs)
    print('Call {fun}() in {time}s'.format(fun=f.__name__,time=time.clock()))
    return costtime

WINDOWS中， time.clock()第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。

@performance
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

#输出：
Call factorial() in 0.034501s
3628800

---

python中编写带参数decorator

考察上面的 @log 装饰器：

def log(f):
    def fn(x):
        print 'call ' + f.__name__ + '()...'
        return f(x)
    return fn

发现对于被装饰的函数，log打印的语句是不能变的（除了函数名）。

如果有的函数非常重要，希望打印出'[INFO] call xxx()...'，有的函数不太重要，希望打印出'[DEBUG] call xxx()...'，这时，log函数本身就需要传入'INFO'或'DEBUG'这样的参数，类似这样：

@log('DEBUG')
def my_func():
    pass

把上面的定义翻译成高阶函数的调用，就是：

my_func = log('DEBUG')(my_func)

所以，带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数：

def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print '[%s] %s()...' % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator

@log('DEBUG')
def test():
    pass
print test()

执行结果：

[DEBUG] test()...
None

上面的@performance只能打印秒，给 @performace 增加一个参数，允许传入's'或'ms'：

import time

def performance(unit):
    def performance_decorator(f):
        time.clock()
        def costtime(*args, **kargs):
            return f(*args, **kargs)
        tag = (1000 if unit=='ms' else 1)
        print('Call {fun}() in {time}{unit}'.format(fun=f.__name__,time=tag*time.clock(),unit=unit))
        return costtime
    return performance_decorator

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

执行结果：

Call factorial() in 38.364ms
3628800

---

python中完善decorator

@decorator可以动态实现函数功能的增加，但是，经过@decorator“改造”后的函数，和原函数相比，除了功能多一点外，有没有其它不同的地方？

在没有decorator的情况下，打印函数名：

def f1(x):
    pass
print f1.__name__

输出： f1

有decorator的情况下，再打印函数名：

def log(f):
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    return wrapper
@log
def f2(x):
    pass
print f2.__name__

输出： wrapper
可见，由于decorator返回的新函数函数名已经不是'f2'，而是@log内部定义的'wrapper'。这对于那些依赖函数名的代码就会失效。decorator还改变了函数的doc等其它属性。如果要让调用者看不出一个函数经过了@decorator的“改造”，就需要把原函数的一些属性复制到新函数中：

def log(f):
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    wrapper.__name__ = f.__name__
    wrapper.__doc__ = f.__doc__
    return wrapper

这样写decorator很不方便，因为我们也很难把原函数的所有必要属性都一个一个复制到新函数上，所以Python内置的functools可以用来自动化完成这个“复制”的任务：

import functools
def log(f):
    @functools.wraps(f)
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    return wrapper

最后需要指出，由于我们把原函数签名改成了(*args, **kw)，因此，无法获得原函数的原始参数信息。
那么带参数的@decorator，@functools.wraps应该放置在哪：

import time, functools

def performance(unit):
    def performance_decorator(f):
        time.clock()
        @functools.wraps(f)
        def costtime(*args, **kargs):
            return f(*args, **kargs)
        tag = (1000 if unit=='ms' else 1)
        print('Call {fun}() in {time}{unit}'.format(fun=f.__name__,time=tag*time.clock(),unit=unit))
        return costtime
    return performance_decorator

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial.__name__