Python修饰器是个非常强大的概念，可以用一个函数去“包装”另一个函数。修饰器的思想，就是把函数中除了正常行为之外的部分抽象出去。这样有很多好处，如很容易进行代码复用，并且能遵守科里定律（即一次只做一件事）。

学习怎样编写修饰器，可以大幅度增加代码的可读性。它能改变函数的行为，而无需实际去改变函数的代码（如添加日志行等）。

而修饰器是Python中非常常用的工具，用过Flask、Click等框架的人，都应该很熟悉修饰器，但许多人只知道怎么用，却不知道该怎么写。如果你也不知道怎么写，那这篇文章，正是为你准备的！

修饰器的原理

首先我们来看一个Python修饰器的例子。下面是个非常简单的例子，演示了修饰器的使用方法。

@my_decoratordef hello():    print('hello')

在Python中定义的函数实际上是个对象。

上面的函数Hello是个函数对象。@my_decorator实际上也是个函数，它接受hello对象，并返回另一个对象给解释器。修饰器返回的对象会成为实际的hello函数。

本质上这跟正常的函数一样，如hello = decorate(hello)。我们传给函数decorate一个函数，decorate可以随便怎样去用这个函数，然后返回另一个对象。修饰器可以干脆吞掉那个函数，或者如果需要，还可以返回某个不是函数的东西。

编写自己的修饰器

前面说过，修饰器就是个简单的函数，它接受函数作为输入，返回一个对象。因此，编写修饰器实际上只需要定义一个函数。

def my_decorator(f):
    return 5

任何函数都可以用作修饰器。这个例子中，修饰器被传入一个函数，然后返回一个不同的东西。它完全吃掉了输入的函数，并且永远返回5。

@my_decorator
def hello():
    print('hello')

>>> hello()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
'int' object is not callable

由于修饰器返回的是INT，INT不是Callable，因此不能作为函数调用。别忘了，修饰器的返回值会替换掉Hello。

>>> hello
5

绝大多数情况下，我们希望修饰器返回的对象能够模拟被修饰的函数。这就是说，修饰器返回的对象应该也是个函数。

例如，假设我们希望在每次函数被调用时输出一行文字，我们可以写个函数输出信息，然后再调用输入的函数。但这个函数必须由修饰器返回。因此我们的函数得写成嵌套的形式，如：

def mydecorator(f):  # f is the function passed to us from python
    def log_f_as_called():
        print(f'{f} was called.')
        f()
    return log_f_as_called

从上面的代码可以看出，我们定义了个嵌套的函数，该嵌套函数被修饰器返回。这样，Hello函数依然可以被当做函数调用，调用者并不知道Hello被修饰过了。现在Hello函数可以这样定义：

@mydecorator
def hello():
    print('hello')

输出如下：

>>> hello()
<function hello at 0x7f27738d7510> was called.
hello

（注意：<function hello at 0x7f27738d7510>中的数字代表内存地址，因此每个人的都会不一样。）

正确包装函数

如果有必要，函数可以被修饰多次。这种情况下，修饰器会引起连锁反应。本质上，每个修饰器的返回值都会传递给上一层的修饰器，直到最顶层。例如，下面的代码：

@a
@b
@c
def hello():
    print('hello')

解释器实际上执行的是hello = a(b(c(hello)))，所有修饰器都会互相包装。你可以用之前定义的修饰器测试这一点，使用两次就好：

@mydecorator
@mydecorator
def hello():
    print('hello')

>>> hello()
<function mydec.<locals>.a at 0x7f277383d378> was called.
<function hello at 0x7f2772f78ae8> was called.
hello

你会注意到，第一个修饰器包装了第二个，然后产生了不同的输出。

有意思的是，第一行输出的结果是<function mydec.<locals>.a at 0x7f277383d378>，而不是像第二行那样输出我们期待的信息：<function hello at 0x7f2772f78ae8>。

这是因为修饰器返回的是个新函数，这个新函数不叫Hello。作为例子来说这无所谓，但实际上这可能会让测试失败，或者让试图自省函数属性的过程失败。

所以，如果修饰器的思想是模拟被修饰的函数的行为，那么它也应该模拟被修饰函数的样子。幸运的是，有个Python标准库functools模块提供的修饰器wraps能做到这一点：

import functools
def mydecorator(f): 
    @functools.wraps(f)  # we tell wraps that the function we are wrapping is f
    def log_f_as_called():
        print(f'{f} was called.')
        f()
    return log_f_as_called

@mydecorator
@mydecorator
def hello():
    print('hello')

>>> hello()
<function hello at 0x7f27737c7950> was called.
<function hello at 0x7f27737c7f28> was called.
hello

现在，新的函数看起来跟它修饰的函数一模一样。但是，我们这个修饰器依然只能修饰不返回任何值，并且不接受任何输入的函数。如果想让它更通用，就必须负责传递函数参数，并且返回同样的值。可以这样修改：

import functools
def mydecorator(f): 
    @functools.wraps(f)  # wraps is a decorator that tells our function to act like f
    def log_f_as_called(*args, **kwargs):
        print(f'{f} was called with arguments={args} and kwargs={kwargs}')
        value = f(*args, **kwargs)
        print(f'{f} return value {value}')
        return value
    return log_f_as_called

现在每次调用都会产生输出，包含函数接收到的所有输入，以及函数的返回值。现在可以用它来修饰任意函数，获得关于函数的输入和输出的调试信息，而用不着手动编写日志代码了。

给修饰器增加变量

如果你写的修饰器不是只给自己用，而是想在产品代码里使用，那你可能需要把所有print语句换成日志输出语句。那样的话就需要定义日志的级别。

都定义成DEBUG级别也许没问题，但还是能根据函数选择级别最好。我们可以给修饰器提供变量，以改变修饰器的行为。例如：

@debug(level='info')
def hello():
    print('hello')

上面的代码可以指定，被修饰的函数应该以info级别输出日志，而不是DEBUG级别。这个功能的实现方法是写个函数，返回修饰器。

没错，修饰器也是个函数。所以这段代码实质上是hello = debug('info')(hello)。两对括号看起来很奇怪，不过本质上说，DEBUG是个返回函数的函数。因此，修改我们之前的修饰器，我们还需要一层嵌套，这样代码如下所示：

import functools
def debug(level): 
    def mydecorator(f)
        @functools.wraps(f)
        def log_f_as_called(*args, **kwargs):
            logger.log(level, f'{f} was called with arguments={args} and kwargs={kwargs}')
            value = f(*args, **kwargs)
            logger.log(level, f'{f} return value {value}')
            return value
        return log_f_as_called
    return mydecorator

上面的修改将DEBUG变成了一个返回修饰器的函数，返回的修饰器会使用正确的日志级别。这段代码看起来不太好看，而且嵌套太多了。

有个很酷的小技巧我非常喜欢，就是给DEBUG添加默认的level参数，返回一个部分函数。部分函数是“不完整的函数调用”，它包含一个函数和一些参数，这样部分函数可以作为一个整体来传递，而无需调用实际的函数。

import functools
def debug(f=None, *, level='debug'): 
    if f is None:
        return functools.partial(debug, level=level)
    @functools.wraps(f)   # we tell wraps that the function we are wrapping is f
    def log_f_as_called(*args, **kwargs):
        logger.log(level, f'{f} was called with arguments={args} and kwargs={kwargs}')
        value = f(*args, **kwargs)
        logger.log(level, f'{f} return value {value}')
        return value
    return log_f_as_called

现在修饰器可以正常工作了：

@debug
def hello():
    print('hello')

这样就会使用DEBUG级别。或者可以覆盖log级别：

@debug('warning')
def hello():
    print('hello')

原文：https://timber.io/blog/decorators-in-python/

作者：Nick Humrich

译者：弯月，责编：胡巍巍