选自pouannes.github.io 作者：Pierre Ouannes 本文由机器之心（nearhuman2014）翻译 原文：https://pouannes.github.io/blog/decorators/

    _
    在 Python 中，函数是一种非常灵活的结构，我们可以把它赋值给变量、当作参数传递给另一个函数，或者当成某个函数的输出。装饰器本质上也是一种函数，它可以让其它函数在不经过修改的情况下增加一些功能。

    这也就是「装饰」的意义，这种「装饰」本身代表着一种功能，如果用它修饰不同的函数，那么也就是为这些函数增加这种功能。

    一般而言，我们可以使用装饰器提供的 @ 语法糖（Syntactic Sugar）来修饰其它函数或对象。如下所示我们用 @dec 装饰器修饰函数 func ()：

    1. @dec
    2. def func():
    3.   pass

    理解装饰器的最好方式是了解装饰器解决什么问题，本文将从具体问题出发一步步引出装饰器，并展示它的优雅与强大。

    设置问题

    为了解装饰器的目的，接下来我们来看一个简单的示例。假如你有一个简单的加法函数 dec.py，第二个参数的默认值为 10：

    1. # dec.py
    3. def add(x, y=10):
    4.   return x + y

    我们来更认真地看一下这个加法函数：

    1. >>> add(10, 20)
    2. 30
    3. >>> add
    4. <function add at 0x7fce0da2fe18>
    5. >>> add.__name__
    6.  add
    7. >>> add.__module__
    8.  __main__
    9. >>> add.__defaults__ # default value of the `add` function
    10. (10,)
    11. >>> add.__code__.co_varnames # the variable names of the `add` function
    12. ( x ,  y )

    我们无需理解这些都是什么，只需要记住 Python 中的每个函数都是对象，它们有各种属性和方法。你还可以通过 inspect 模块查看 add() 函数的源代码：

    1. >>> from inspect import getsource
    2. >>> print(getsource(add))
    4. def add(x, y=10):
    5.   return x + y

    现在你以某种方式使用该加法函数，比如你使用一些操作来测试该函数：

    1. # dec.py
    2. from time import time
    4. def add(x, y=10):
    5.   return x + y
    7. print( add(10) ,         add(10))
    8. print( add(20, 30) ,     add(20, 30))
    9. print( add("a", "b") ,   add("a", "b"))
    10. Output: i
    12. add(10) 20
    13. add(20, 30) 50
    14. add("a", "b") ab

    假如你想了解每个操作的时间，可以调用 time 模块：

    1. # dec.py
    2. from time import time
    5. def add(x, y=10):
    6.   return x + y
    8. before = time()
    9. print( add(10) ,         add(10))
    10. after = time()
    11. print( time taken:  , after - before)
    12. before = time()
    13. print( add(20, 30) ,     add(20, 30))
    14. after = time()
    15. print( time taken:  , after - before)
    16. before = time()
    17. print( add("a", "b") ,   add("a", "b"))
    18. after = time()
    19. print( time taken:  , after - before)
    20. Output:
    22. add(10) 20
    23. time taken:  6.699562072753906e-05
    24. add(20, 30) 50
    25. time taken:  6.9141387939453125e-06
    26. add("a", "b") ab
    27. time taken:  6.9141387939453125e-06

    现在，你作为一个编程人员是不是有些手痒，毕竟我们不喜欢总是复制粘贴相同的代码。现在的代码可读性不强，如果你想改变什么，你就得修改所有出现的地方，Python 肯定有更好的方式。

    我们可以按照如下做法，直接在 add 函数中捕捉运行时间：

    1. # dec.py
    2. from time import time
    4. def add(x, y=10):
    5.   before = time()
    6.   rv = x + y
    7.   after = time()
    8.   print( time taken:  , after - before)
    9.   return rv
    11. print( add(10) ,         add(10))
    12. print( add(20, 30) ,     add(20, 30))
    13. print( add("a", "b") ,   add("a", "b"))

    这种方法肯定比前一种要好。但是如果你还有另一个函数，那么这似乎就不方便了。当我们有多个函数时：

    1. # dec.py
    2. from time import time
    4. def add(x, y=10):
    5.   before = time()
    6.   rv = x + y
    7.   after = time()
    8.   print( time taken:  , after - before)
    9.   return rv
    11. def sub(x, y=10):
    12.   return x - y
    14. print( add(10) , add(10))
    15. print( add(20, 30) , add(20, 30))
    16. print( add("a", "b") , add("a", "b"))
    17. print( sub(10) , sub(10))
    18. print( sub(20, 30) , sub(20, 30))

    因为 add 和 sub 都是函数，我们可以利用这一点写一个 timer 函数。我们希望 timer 能计算一个函数的运算时间：

    1. def timer(func, x, y=10):
    2.   before = time()
    3.   rv = func(x, y)
    4.   after = time()
    5.   print( time taken:  , after - before)
    6.   return rv

    这很不错，不过我们必须使用 timer 函数包装不同的函数，如下所示：

    1. print( add(10) , timer(add,10)))

    现在默认值还是 10 吗？未必。那么如何做得更好呢？

    这里有一个主意：创建一个新的 timer 函数，并包装其他函数，然后返回包装后的函数：

    1. def timer(func):
    2.   def f(x, y=10):
    3.     before = time()
    4.     rv = func(x, y)
    5.     after = time()
    6.     print( time taken:  , after - before)
    7.     return rv
    8.   return f

    现在，你只需用 timer 包装一下 add 和 sub 函数 ：

    1. add = timer(add)

    这样就可以了！以下是完整代码：

    1. # dec.py
    2. from time import time
    3. def timer(func):
    4.   def f(x, y=10):
    5.     before = time()
    6.     rv = func(x, y)
    7.     after = time()
    8.     print( time taken:  , after - before)
    9.     return rv
    10.   return f
    12. def add(x, y=10):
    13.   return x + y
    14. add = timer(add)
    17. def sub(x, y=10):
    18.   return x - y
    19. sub = timer(sub)
    21. print( add(10) ,         add(10))
    22. print( add(20, 30) ,     add(20, 30))
    23. print( add("a", "b") ,   add("a", "b"))
    24. print( sub(10) ,         sub(10))
    25. print( sub(20, 30) ,     sub(20, 30))
    26. Output:
    28. time taken:  0.0
    29. add(10) 20
    30. time taken:  9.5367431640625e-07
    31. add(20, 30) 50
    32. time taken:  0.0
    33. add("a", "b") ab
    34. time taken:  9.5367431640625e-07
    35. sub(10) 0
    36. time taken:  9.5367431640625e-07
    37. sub(20, 30) -10

    我们来总结一下这个过程：我们有一个函数（比如 add 函数），然后用一个动作（比如计时）包装该函数。包装的结果是一个新函数，能实现某些新功能。

    当然了，默认值还有点问题，稍后我们会解决它。

    装饰器
    **
    现在，上面的解决方案以及非常接近装饰器的思想了，使用常见行为包装某个具体的函数，这种模式就是装饰器在做的事。使用装饰器后的代码是：

    1. def add(x, y=10):
    2.   return x + y
    3. add = timer(add)
    4. You write:
    6. @timer
    7. def add(x, y=10):
    8.   return x + y

    它们的作用是一样的，这就是 Python 装饰器的作用。它实现的作用类似于 add = timer(add)，只不过装饰器把句法放在函数上面，且句法更加简单：@timer。

    1. # dec.py
    2. from time import time
    3. def timer(func):
    4.   def f(x, y=10):
    5.     before = time()
    6.     rv = func(x, y)
    7.     after = time()
    8.     print( time taken:  , after - before)
    9.     return rv
    10.   return f
    12. @timer
    13. def add(x, y=10):
    14.   return x + y
    16. @timer
    17. def sub(x, y=10):
    18.   return x - y
    20. print( add(10) ,         add(10))
    21. print( add(20, 30) ,     add(20, 30))
    22. print( add("a", "b") ,   add("a", "b"))
    23. print( sub(10) ,         sub(10))
    24. print( sub(20, 30) ,     sub(20, 30))

    参数和关键字参数

    现在，还有一个小问题没有解决。在 timer 函数中，我们将参数 x 和 y 写死了，即指定 y 的默认值为 10。有一种方法可以传输该函数的参数和关键字参数，即 *args 和     kwargs。参数是函数的标准参数（在本例中 x 为参数），关键字参数是已具备默认值的参数（本例中是 y=10）。代码如下：

    1. # dec.py
    2. from time import time
    3. def timer(func):
    4.   def f(*args, **kwargs):
    5.     before = time()
    6.     rv = func(*args, **kwargs)
    7.     after = time()
    8.     print( time taken:  , after - before)
    9.     return rv
    10.   return f
    12. @timer
    13. def add(x, y=10):
    14.   return x + y
    16. @timer
    17. def sub(x, y=10):
    18.   return x - y
    20. print( add(10) ,         add(10))
    21. print( add(20, 30) ,     add(20, 30))
    22. print( add("a", "b") ,   add("a", "b"))
    23. print( sub(10) ,         sub(10))
    24. print( sub(20, 30) ,     sub(20, 30))

    现在，该 timer 函数可以处理任意函数、任意参数和任意默认值设置了，因为它仅仅将这些参数传输到函数中。

    高阶装饰器

    你们可能会疑惑：如果我们可以用一个函数包装另一个函数来添加有用的行为，那么我们可以再进一步吗？我们用一个函数包装另一个函数，再被另一个函数包装吗？

    可以！事实上，函数的深度可以随你的意。例如，你想写一个装饰器来执行某个函数 n 次。如下所示：

    1. def ntimes(n):
    2.   def inner(f):
    3.     def wrapper(*args, **kwargs):
    4.       for _ in range(n):
    5.         rv = f(*args, **kwargs)
    6.       return rv
    7.     return wrapper
    8.   return inner

    然后你可以使用上述函数包装另一个函数，例如前文中的 add 函数：

    1. @ntimes(3)
    2. def add(x, y):
    3.   print(x + y)
    4.   return x + y

    输出的语句表明该代码确实执行了 3 次。