Python进阶之decorator装饰器

decorator装饰器
.note-content {font-family: "Helvetica Neue",Arial,"Hiragino Sans GB","STHeiti","Microsoft YaHei","WenQuanYi Micro Hei",SimSun,Song,sans-serif;}

.note-content h2 {line-height: 1.6; color: #0AA89E;}
.note-content {background: #FFFFFF;}
.note-content h1 {color: #7AB3A7;}
.note-content h3 {color: #147A67;}

decorator装饰器

1. 什么是装饰器

假设我们定义了一个函数，想在运行时动态增加功能，但是又不想改动函数本身的代码。

举个例子，假如我们希望对下列函数调用增加log功能，打印出函数调用：

1.def f1(x):
2.    return x*2
3.def f2(x):
4.    return x*x
5.def f3():
6.    return x*x*x

方法一，直接修改原函数：

1.def f1(x):
2.    print 'call f1()'
3.    return x*2
4.def f2(x):
5.    print 'call f2()'
6.    return x*x
7.def f3():
8.    print 'call f3()'
9.    return x*x*x

方法二，通过高阶函数返回新函数

1.def f1(x):
2.    return x*2
3.def new_fn(f):#装饰器函数
4.    def fn(x):
5.        print 'call'+f.__name__+'()'
6.        return f(x)
7.    return fn
8.
9.#调用
10.g1=new_fn(f1)
11.print g1(5)
12.
13.f1=new_fn(f1)
14.print f1(5)
15.#f1的原始定义函数被彻底隐藏了

那么Python内置的@语法就是为了简化装饰器调用

1.@new_fn
2.def f1(x):
3.    return x*2

它的作用就相当于

1.def f1(x):
2.    return x*2
3.f1=new_fn(f1)

2. 装饰器的作用

• 可以极大地简化代码，避免每个函数编写重复性代码
  
  打印日志：@log
  
  检测性能：@performance
  
  数据库事务：@transaction
  
  URL路由：@post('/register' )

3. 编写无参数decorator

考察一个@log的定义：

1.def log(f):
2.    def fn(x):
3.        print 'call ' + f.__name__ + '()...'
4.        return f(x)
5.    return fn

对于阶乘函数，@log工作得很好：

1.@log
2.def factorial(n):
3.    return reduce(lambda x,y:x*y,range(1,n+1))
4.print factorial(10)

输出结果：

1.call factorial()...
2.362880

但是，如果对于参数不是一个函数，调用将要报错：

1.@log
2.def add(x, y):
3.    return x + y
4.print add(1, 2)

输出结果：

1.Traceback (most recent call last):
2.  File "test.py", line 15, in <module>
3.    print add(1,2)
4.TypeError: fn() takes exactly 1 argument (2 given)

因为 add() 函数需要传入两个参数，但是 @log 写死了只含一个参数的返回函数。

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

1.def log(f):
2.    def fn(*args, **kw):
3.        print 'call ' + f.__name__ + '()...'
4.        return f(*args, **kw)
5.    return fn

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

举个栗子，编写一个@performance，它可以打印出函数调用的时间。

1.import time
2.
3.def performance(f):
4.    def fn(*args,**kw):
5.        t1=time.time()
6.        r=f(*args,**kw)
7.        t2=time.time()
8.        print 'call %s() in %fs' % (f.__name__,(t2-t1))
9.        return r
10.    return fn
11.
12.@performance
13.def factorial(n):
14.    return reduce(lambda x,y: x*y, range(1, n+1))
15.
16.print factorial(10)

4. 编写带参数的decorator

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

1.@log('DEBUG')
2.def my_func():
3.    pass

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

1.my_func = log('DEBUG')(my_func)

再展开一下：

1.log_decorator = log('DEBUG')
2.my_func = log_decorator(my_func)

上面的语句又相当于：

1.log_decorator = log('DEBUG')
2.@log_decorator
3.def my_func():
4.    pass

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

1.def log(prefix):
2.    def log_decorator(f):
3.        def wrapper(*args, **kw):
4.            print '[%s] %s()...' % (prefix, f.__name__)
5.            return f(*args, **kw)
6.        return wrapper
7.    return log_decorator
8.
9.@log('DEBUG')
10.def test():
11.    pass
12.print test()

输出结果：

1.[DEBUG] test()...
2.None

对于这种3层嵌套的decorator定义，你可以先把它拆开：

1.# 标准decorator:
2.def log_decorator(f):
3.    def wrapper(*args, **kw):
4.        print '[%s] %s()...' % (prefix, f.__name__)
5.        return f(*args, **kw)
6.    return wrapper
7.return log_decorator
8.
9.# 返回decorator:
10.def log(prefix):
11.    return log_decorator(f)

拆开以后会发现，调用会失败，因为在3层嵌套的decorator定义中，最内层的wrapper引用了最外层的参数prefix，所以，把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。

再举个栗子，

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

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

1.import time
2.
3.def performance(unit):
4.    def perf_decorator(f):
5.        def wrapper(*args,**kw):
6.            t1=time.time()
7.            r=f(*args,**kw)
8.            t2=time.time()
9.            t=(t2-t1)*1000 if unit=='ms' else (t2-t1)
10.            print 'call %s() in %f %s' % (f.__name__,t,unit)
11.            return r
12.        return wrapper
13.    return perf_decorator
14.
15.@performance('ms')
16.def factorial(n):
17.    return reduce(lambda x,y: x*y, range(1, n+1))
18.
19.print factorial(10)

5. 完善decorator

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

1.def f1(x):
2.    pass
3.print f1.__name__

输出：f1

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

1.def log(f):
2.    def wrapper(*args, **kw):
3.        print 'call...'
4.        return f(*args, **kw)
5.    return wrapper
6.@log
7.def f2(x):
8.    pass
9.print f2.__name__

输出： wrapper

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

1.def log(f):
2.    def wrapper(*args, **kw):
3.        print 'call...'
4.        return f(*args, **kw)
5.    wrapper.__name__ = f.__name__
6.    wrapper.__doc__ = f.__doc__
7.    return wrapper

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

1.import functools
2.def log(f):
3.    @functools.wraps(f)
4.    def wrapper(*args, **kw):
5.        print 'call...'
6.        return f(*args, **kw)
7.    return wrapper

最后需要指出，由于我们把原函数签名改成了(*args, **kw)，因此，无法获得原函数的原始参数信息。即便我们采用固定参数来装饰只有一个参数的函数：

1.def log(f):
2.    @functools.wraps(f)
3.    def wrapper(x):
4.        print 'call...'
5.        return f(x)
6.    return wrapper

也可能改变原函数的参数名，因为新函数的参数名始终是 ‘x‘，原函数定义的参数名不一定叫 ‘x‘。

再举个栗子，

1.def performance(unit):
2.    def perf_decorator(f):
3.        def wrapper(*args, **kw):
4.            ???
5.        return wrapper
6.    return perf_decorator

带参数的@decorator，@functools.wraps应该放置在哪？

1.import time, functools
2.def performance(unit):
3.    def perf_decorator(f):
4.        @functools.wraps(f)
5.        def wrapper(*args, **kw):
6.            t1 = time.time()
7.            r = f(*args, **kw)
8.            t2 = time.time()
9.            t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
10.            print 'call %s() in %f %s' % (f.__name__, t, unit)
11.            return r
12.        return wrapper
13.    return perf_decorator
14.
15.@performance('ms')
16.def factorial(n):
17.    return reduce(lambda x,y: x*y, range(1, n+1))
18.print factorial.__name__