python--decorator装饰器

Posted 石明昊

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python--decorator装饰器相关的知识,希望对你有一定的参考价值。

decorator装饰器

什么是装饰器

问题:

定义了一个函数

想在运行时动态增加功能

又不想改变函数本身的代码

解决:

利用高阶函数,接收一个函数并对其进行包装,然后返回一个函数

代码

def f1(x): #被装饰函数
    return x * x
def new_fn(f): #装饰器函数
    def fn(x):
        print("Call" + f.__name__ + "()")
        return f(x)
    return fn
#调用方法1
g1 = new_fn(f1)
print(g1(5))
#调用方法2,此种调用完全隐蔽了f1原始定义
f1 = new_fn(f1)
print(f1(5))

运行结果

Callf1()
25
Callf1()
25

@语法

python内置的@语法是为了简化语法,接着上面的示例代码:

@new_fn #相当于f1 = new_fn(f1)
def f1(x): #被装饰函数
    return x * x

装饰器作用

极大简化代码,避免每个函数编写重复性代码

打印日志@log

检测性能@performance

数据库事务@transaction

URL路由@post(‘/register‘)

无参数decorator

Python的 decorator 本质上就是一个高阶函数,它接收一个函数作为参数,然后,返回一个新函数。

使用 decorator 用Python提供的 @ 语法,这样可以避免手动编写 f = decorate(f) 这样的代码。

考察一个@log的定义:

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

对于阶乘函数,@log工作得很好:

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

结果:

call factorial()...
3628800

但是,对于参数不是一个的函数,调用将报错:

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

结果:

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

因为 add() 函数需要传入两个参数,但是 @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
from functools import reduce
def performance(f):
    def fn(*args, **kw):
        t1 = time.time()
        r = f(*args, **kw)
        t2 = time.time()
        print (call %s() in %fs % (f.__name__, (t2 - t1)))
        return r
    return fn

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

print (factorial(10))

运行结果

call factorial() in 0.000000s
3628800

带参数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 = log(DEBUG)
my_func = log_decorator(my_func)

上面的语句又相当于:

log_decorator = log(DEBUG)
@log_decorator
def my_func():
    pass

所以,带参数的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

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

# 标准decorator:
def log_decorator(f):
    def wrapper(*args, **kw):
        print [%s] %s()... % (prefix, f.__name__)
        return f(*args, **kw)
    return wrapper
return log_decorator

# 返回decorator:
def log(prefix):
    return log_decorator(f)

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

任务

上一节的@performance只能打印秒,请给 @performace 增加一个参数,允许传入‘s‘或‘ms‘:

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

代码

import time
from functools import reduce
def performance(unit):
    def perf_decorator(f):
        def wrapper(*args, **kw):
            t1 = time.time()
            r = f(*args, **kw)
            t2 = time.time()
            t = (t2 - t1) * 1000 if unit==ms else (t2 - t1)
            print (call %s() in %f %s % (f.__name__, t, unit))
            return r
        return wrapper
    return perf_decorator

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

运行结果

call factorial() in 0.000000 ms
3628800

完善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),因此,无法获得原函数的原始参数信息。即便我们采用固定参数来装饰只有一个参数的函数:

def log(f):
    @functools.wraps(f)
    def wrapper(x):
        print call...
        return f(x)
    return wrapper

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

任务

请思考带参数的@decorator,@functools.wraps应该放置在哪:

def performance(unit):
    def perf_decorator(f):
        def wrapper(*args, **kw):
            ???
        return wrapper
    return perf_decorator

代码

import time, functools

def performance(unit):
    def fn(f):
        @functools.wraps(f)
        def f1(*args,**kw):
            print(call  + f.__name__ + () in  + "%s" % time.ctime())
            print([%s] %s()... % (unit, f.__name__))
            return f(*args,**kw)
        return f1
    return fn

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

print (factorial.__name__)

运行结果

factorial

以上是关于python--decorator装饰器的主要内容,如果未能解决你的问题,请参考以下文章

Python decorator

python decorator

python decorator

python decorator 进阶

python 装饰器

python Decorator