python函数式编程之装饰器

函数是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用函数，函数有一个__name__属性，可以拿到函数的名字:

 

>>> def now():
...     print('2017-5-18')
...
>>> f = now
>>> f()
2015-3-25

 

 

>>> now.__name__
'now'
>>> f.__name__
'now'

假如要增强now()函数的功能，比如：在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为”装饰器(decorator)“,本质上，decorator就是返回番薯的高阶函数；定义如下：

 

 

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

log()函数，它是一个decorator,接受一个函数作为参数，并返回一个函数。这里可以借助于python的@语法，把decorator置于函数的定义处：

 

@log
def now():
    print('2017-5-18')

 

调用now()函数，不仅会运行now()函数本身，还会运行now()函数前打印一行日志：

 

>>> now()
call now():
2017-5-18

把@log放到now()函数的定义出，相当于执行了语句：now=log(now)
由于log()是一个装饰器，返回的是一个函数，所以说，原来的函数仍然存在，只是现在的now()指向了新的函数，于是调用now()将执行新的函数，即在log()函数中返回wrapper()函数。wrapper()函数的参数定义是（*args,**kw）,因此wrapper函数可以接受任意参数的调用，在wrapper()函数内，首先打印日志，再接着调用原始的now()函数。
如果decorator本身需要传入参数，那就需要编写一个返回decorator的高级函数，比如，自定义log的文本：

 

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

三层嵌套的decorator：

 

@log('execute')
def now():
    print('2017-5-18')

执行结果：

 

 

>>> now()
execute now():
2017-5-18

和2层嵌套的decorator的相比较，3层嵌套的效果是：

 

 

>>> now = log('execute')(now)

首先执行的是log("execute"),返回的是decorator函数，在调用返回的函数，参数是now函数，返回值最终是wrapper函数，但是经过decorator装饰之后的函数，他的__name__变成了”wrapper“：

 

>>> now.__name__
'wrapper'

因为返回那个wrapper()函数名字就是”wrapper“，需要把原始函数的__name__属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。
不需要编写wrapper.__name__=func.__name__这样的代码，python内置functools.wraps就是干这个事的，一个完整的decorator写法如下：

 

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

带参数的decorator：

 

 

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

编写一个decorator，可以在函数调用前后打印”begin call“和”end call“的日志：

 

 

 

 

def log(func):
    def wrapper(*args, **kw):
        print('begin call %s():' % func.__name__)
        func(*args, **kw)
        print('end call %s():' % func.__name__)
    return wrapper

@log
def now():
    print (time.strftime('%Y-%m-%d',time.localtime(time.time())))

now()

带参数：

 

 

 

 

def log(strorfunc):
    if isinstance(strorfunc,str):
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kw):
                print('%s %s():' % (strorfunc, func.__name__))
                func(*args, **kw)
            return wrapper
        return decorator
    else:
        @functools.wraps(strorfunc)
        def wrapper(*args, **kw):
            print('begin call %s():' %  strorfunc.__name__)
            strorfunc(*args, **kw)
            print('end call %s():' % strorfunc.__name__)
        return wrapper

@log('execute')
def now():
    print (time.strftime('%Y-%m-%d',time.localtime(time.time())))

now()

总结：
在面向对象(OOP)的设计模式中，decorator称之为装饰模式，OOP的装饰模式需要通过继承和组合来实现，而python除了支持OOP的decorator外，直接从语法层支持decorator。python中的decorator可以用函数实现（decorator可以增强函数的功能），也可以用类来实现。