python-装饰器

2018-12-04 10:20:29

装饰器(Decorators)是 Python 的一个重要部分。简单地说：他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短，也更Pythonic。大多数初学者不知道在哪儿使用它们，所以我将要分享下，哪些区域里装饰器可以让你的代码更简洁。 首先，让我们讨论下如何写你自己的装饰器。

装饰器本质上是一个函数。它把一个函数作为输入并且返回另外一个函数。在装饰器中，通常使用下面的这些python技巧：

• *args和**kwargs
• 闭包
• 作为参数的函数

简单的来说，装饰器让你在一个函数的前后去执行代码。

 

一、简单实现一个装饰器

def a_new_decorator(a_func):
    """
    装饰器，以函数为输入，返回经过修饰的函数
    """
    def wrapTheFunction():
        print("I am doing some boring work before executing a_func()")
        a_func()
        print("I am doing some boring work after executing a_func()")

    return wrapTheFunction


def a_function_requiring_decoration():
    print("I am the function which needs some decoration to remove my foul smell")


if __name__ == "__main__":
    # 添加装饰器
    a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
    # 调用装饰器
    a_function_requiring_decoration()

这正是 python 中装饰器做的事情！它们封装一个函数，并且用这样或者那样的方式来修改它的行为。

@ 符号是一个简短的方式来生成一个被装饰的函数，这一点和Java中的注解注入是很类似的，这里是我们使用 @ 来运行之前的代码： 

def a_new_decorator(a_func):
    """
    装饰器，以函数为输入，返回经过修饰的函数
    """
    def wrapTheFunction():
        print("I am doing some boring work before executing a_func()")
        a_func()
        print("I am doing some boring work after executing a_func()")

    return wrapTheFunction

@a_new_decorator
def a_function_requiring_decoration():
    """
    使用注解的方式，等价于: a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
    """
    print("I am the function which needs some decoration to remove my foul smell")


if __name__ == "__main__":
    a_function_requiring_decoration()　　

 

二、functools.wraps

使用上述的两种方式生成装饰器函数这里有个问题，就是在采用这种方式进行装饰的时候，最后返回的函数已经变成了wrapTheFunction()，那么当我们查看函数的说明的时候就会丢失掉原来函数的说明，如下的代码所描述的：

print(a_function_requiring_decoration.__name__)
# Output: wrapTheFunction

这并不是我们想要的！Ouput输出应该是"a_function_requiring_decoration"。这里的函数被warpTheFunction替代了。它重写了我们函数的名字和注释文档(docstring)。幸运的是Python提供给我们一个简单的函数来解决这个问题，那就是functools.wraps。我们修改上一个例子来使用functools.wraps：

from functools import wraps


def a_new_decorator(a_func):
    """
    装饰器，以函数为输入，返回经过修饰的函数
    """
    @wraps(a_func)
    def wrapTheFunction():
        print("I am doing some boring work before executing a_func()")
        a_func()
        print("I am doing some boring work after executing a_func()")

    return wrapTheFunction


@a_new_decorator
def a_function_requiring_decoration():
    """
    使用注解的方式，等价于: a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
    """
    print("I am the function which needs some decoration to remove my foul smell")


if __name__ == "__main__":
    a_function_requiring_decoration()
    print(a_function_requiring_decoration.__name__)

注意：@wraps接受一个函数来进行装饰，并加入了复制函数名称、注释文档、参数列表等等的功能。这可以让我们在装饰器里面访问在装饰之前的函数的属性。

由于func函数有可能是带参数的函数，那么就需要将参数一起传给wrap函数，而@wraps(f)正好可以进行参数的复制，因此可以将func原先的参数传递到装饰器函数中，由于我们事先不知道会有多少参数，以及是否含有字典类型，因此这里的参数表最好写成*args, **kwargs，*args会将不定长的参数以元组的形式传入，**kwargs会将字典类型的数据传入。

这里提供一个使用装饰器的蓝本：

from functools import wraps


def a_new_decorator(a_func):
    """
    装饰器，以函数为输入，返回经过修饰的函数
    """
    @wraps(a_func)
    def wrapTheFunction(*args, **kwargs):
        print("I am doing some boring work before executing a_func()")
        a_func(*args, **kwargs)
        print("I am doing some boring work after executing a_func()")

    return wrapTheFunction


@a_new_decorator
def a_function_requiring_decoration(a, b):
    """
    使用注解的方式，等价于: a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
    """
    print("I am the function which needs some decoration; calc_res = %s" % (a + b))


if __name__ == "__main__":
    a_function_requiring_decoration(1, 2)

 

三、装饰器的使用场景

• 授权(Authorization)

装饰器能有助于检查某个人是否被授权去使用一个web应用的端点(endpoint)。它们被大量使用于Flask和Django web框架中。这里是一个例子来使用基于装饰器的授权：

from functools import wraps
 
def requires_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            authenticate()
        return f(*args, **kwargs)
    return decorated

• 日志(Logging) 

日志是装饰器运用的另一个亮点。这是个例子：

from functools import wraps
 
def logit(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print(func.__name__ + " was called")
        return func(*args, **kwargs)
    return with_logging
 
@logit
def addition_func(x):
   """Do some math."""
   return x + x
 
 
result = addition_func(4)
# Output: addition_func was called

 

四、带参数的装饰器

来想想这个问题，难道@wraps不也是个装饰器吗？但是，它接收一个参数，就像任何普通的函数能做的那样。那么，为什么我们不也那样做呢？

那么问题就是如何将参数传到装饰器中呢？我们可以再对原来的装饰器函数进行一次封装，通过这种方式将参数给到装饰器。

from functools import wraps
 
def logit(logfile='out.log'):
    def logging_decorator(func):
        @wraps(func)
        def wrapped_function(*args, **kwargs):
            log_string = func.__name__ + " was called"
            print(log_string)
            # 打开logfile，并写入内容
            with open(logfile, 'a') as opened_file:
                # 现在将日志打到指定的logfile
                opened_file.write(log_string + '\n')
            return func(*args, **kwargs)
        return wrapped_function
    return logging_decorator
 
@logit()
def myfunc1():
    pass
 
myfunc1()
# Output: myfunc1 was called
# 现在一个叫做 out.log 的文件出现了，里面的内容就是上面的字符串
 
@logit(logfile='func2.log')
def myfunc2():
    pass
 
myfunc2()
# Output: myfunc2 was called
# 现在一个叫做 func2.log 的文件出现了，里面的内容就是上面的字符串

原先我们直接使用@logit，代表func = logit(func)，这里我们需要给装饰器传入参数，使用@logit(logfile = "func.log")，代表func = logit(logfile = "func.log")(func)。

 

五、装饰器类

现在我们有了能用于正式环境的logit装饰器，但当我们的应用的某些部分还比较脆弱时，异常也许是需要更紧急关注的事情。比方说有时你只想打日志到一个文件。而有时你想把引起你注意的问题发送到一个email，同时也保留日志，留个记录。这是一个使用继承的场景，但目前为止我们只看到过用来构建装饰器的函数。

幸运的是，类也可以用来构建装饰器。那我们现在以一个类而不是一个函数的方式，来重新构建logit。

from functools import wraps
 
class logit(object):
    def __init__(self, logfile='out.log'):
        self.logfile = logfile
 
    def __call__(self, func):
        @wraps(func)
        def wrapped_function(*args, **kwargs):
            log_string = func.__name__ + " was called"
            print(log_string)
            # 打开logfile并写入
            with open(self.logfile, 'a') as opened_file:
                # 现在将日志打到指定的文件
                opened_file.write(log_string + '\n')
            # 现在，发送一个通知
            self.notify()
            return func(*args, **kwargs)
        return wrapped_function
 
    def notify(self):
        # logit只打日志，不做别的
        pass

这个实现有一个附加优势，在于比嵌套函数的方式更加整洁，而且包裹一个函数还是使用跟以前一样的语法：

@logit()
def myfunc1():
    pass

现在，我们给 logit 创建子类，来添加 email 的功能(虽然 email 这个话题不会在这里展开)。

class email_logit(logit):
    '''
    一个logit的实现版本，可以在函数调用时发送email给管理员
    '''
    def __init__(self, email='admin@myproject.com', *args, **kwargs):
        self.email = email
        super(email_logit, self).__init__(*args, **kwargs)
 
    def notify(self):
        # 发送一封email到self.email
        # 这里就不做实现了
        pass

从现在起，@email_logit 将会和 @logit 产生同样的效果，但是在打日志的基础上，还会多发送一封邮件给管理员。