装饰器

装饰器应用广泛，其特点是可在具体函数执行之前或者之后做相关操作。

比如

• 执行前打印执行函数的相关信息，对函数的参数进行校验；
• 执行后记录函数调用的相关流水日志等。

好处

使得函数功能单一化，仅仅处理业务逻辑，而不附带其它功能。

例：

在函数调用前打印时间函数名相关的信息。

不使用装饰器可以用如下代码实现：

from time import ctime
def foo():
    print('[%s]  %s() is called' % (ctime(), foo.__name__))
    print('Hello, Python')

这样写的问题是业务逻辑中会夹杂参数检查，日志记录等信息，使得代码逻辑不够清晰。所以，这种场景需要使用装饰器：

from time import ctime

def deco(func):
    def decorator(*args, **kwargs):
        print('[%s]  %s() is called' % (ctime(), func.__name__))
        return func(*args, **kwargs)
    return decorator

@deco
def foo():
    print('Hello, Python')

foo()
>>>[Sun Oct 28 17:11:01 2018]  foo() is called
Hello, Python

深入理解装饰器

装饰器本质上也是函数，接受函数对象来作为参数，并在装饰器的内部来调用接受的函数对象完成相关的函数调用。也可以这样理解，为了方便在几个不同函数调用之前或者之后完成相关的统一操作，注意是完成统一的操作，可以传参数使得装饰器不完全一样，后面会讲到。最重要的应用如工程应用上记录相关的内部调用接口的流水日志，不同的接口需要统一的样式，所以可以用装饰器来实现。先简单看一下示例：

from time import ctime

def deco(func):
    def decorator(*args, **kwargs):
        print('[%s]  %s() is called' % (ctime(), func.__name__))
        return func(*args, **kwargs)
    return decorator

@deco 
def foo():
    print('Hello, Python')

foo()

在如上示例中，定义了一个装饰器，其中参数func需要函数的对象，返回值是decorator函数，其中decorator函数的返回值正是func的返回值。该装饰器的功能就是在函数调用之前，打印了函数调用的时间和函数名。

装饰器的使用过程很简单，通过注解@符号标注一下即可。这本质上相当于foo = deco(foo) 的嵌套调用。

这里面，你又遇到了 *args 和 **kwargs，它们可以组合接收任意函数参数。不理解的可以翻看 Python 中的 *args 和 **kwargs 。

装饰器也可以堆叠起来，即对某个函数使用多个装饰器，比如：

from time import ctime

def deco1(func):
    def decorator1(*args, **kwargs):
        print('[%s]  %s() is called' % (ctime(), func.__name__))
        return func(*args, **kwargs)
    return decorator1

def deco2(func):
    def decorator2(*args, **kwargs):
        print('[%s]  %s() is called' % (ctime(), func.__name__))
        return func(*args, **kwargs)
    return decorator2

@deco2 
@deco1 
def foo():
    print('Hello, Python')

foo()

会输出什么呢？可以先分析一下。

运行一下，输出如下：

[Fri Jul 21 15:15:53 2017]  decorator1() is called
[Fri Jul 21 15:15:53 2017]  foo() is called
Hello, Python

是否跟你想的一样？在嵌套调用的过程中，foo = deco2(deco1(foo))，所以先返回 deco1(foo) 的函数名字即 decorator1， 后返回 foo 的函数名。

装饰器本身也可以传入参数，使得在统一的过程中带点奇特的色彩，如：

from time import ctime
def deco(tag):
    def decorator(func):
        def wrapper(*args, **kw):
            print('[%s]  %s() is called, Tag is %s.' % (ctime(), func.__name__, tag))
            return func(*args, **kw)
        return wrapper
    return decorator

@deco('Python')
def foo():
    print('Hello, Python')

@deco('Java')
def bar():
    print('Hello, Python')

foo()
bar()

让我们简单分析下这个装饰器，deco函数接受的是一个str对象tag，当执行deco('Python') 后返回的是decorator函数，此函数需要接受一个函数对象，同时返回wrapper函数，而wrapper函数的结果就是func函数的返回值。说的可能有点绕，但理一下会觉得非常简单。

最后说明一下的是，由于加入了装饰器，函数的name和doc等信息都发生了变化：

from time import ctime

def deco(func):
    def decorator(*args, **kwargs):
        '''decorator for func'''
        print('[%s]  %s() is called' % (ctime(), func.__name__))
        return func(*args, **kwargs)
    return decorator

@deco 
def foo():
    '''function: foo'''
    print('Hello, Python')

foo.__name__ foo.__doc__</pre>

运行的结果如下：

decorator
decorator for func

由此可见，加入装饰器改变了函数内部的相关属性。如何避免此问题呢？Python中有专门的包来避免这种转换：functools.wraps。示例如下：

from time import ctime
import functools

def deco(func):
    @functools.wraps(func)
    def decorator(*args, **kwargs):
        '''decorator for func'''
        print('[%s]  %s() is called' % (ctime(), func.__name__))
        return func(*args, **kwargs)
    return decorator

@deco def foo():
    '''function: foo'''
    print('Hello, Python')

foo.__name__ foo.__doc__

运行结果如下：

foo
function: foo

这样就保留了原先函数的属性。

整理自《曹金龙 Python那些事 2017-07-22》