Python 装饰器

装饰器接收一个函数，添加一些功能并返回它。在本教程中，您将了解如何创建装饰器以及为什么要使用它。

视频：Python 中的@Decorators

Python 中的装饰器

Python 有一个有趣的特性，叫做 decorators 为现有代码添加功能。

这也称为元编程 因为程序的一部分试图在编译时修改程序的另一部分。

学习装饰器的先决条件

要想了解装饰器，我们首先要了解一些 Python 的基本知识。

我们必须对 Python 中的一切（是的！甚至是类）都是对象这一事实感到满意。我们定义的名称只是绑定到这些对象的标识符。函数也不例外，它们也是对象（带有属性）。同一个函数对象可以绑定各种不同的名字。

这是一个例子。

def first(msg):
    print(msg)


first("Hello")

second = first
second("Hello")

输出

Hello
Hello

运行代码时，两个函数 first 和 second 给出相同的输出。在这里，名称 first 和 second 引用同一个函数对象。

现在事情开始变得越来越奇怪了。

函数可以作为参数传递给另一个函数。

如果你使用过 map 之类的函数 , filter 和 reduce 在 Python 中，你已经知道了。

将其他函数作为参数的此类函数也称为高阶函数 .这是一个这样的函数的例子。

def inc(x):
    return x + 1


def dec(x):
    return x - 1


def operate(func, x):
    result = func(x)
    return result

我们调用函数如下。

>>> operate(inc,3)
4
>>> operate(dec,3)
2

此外，一个函数可以返回另一个函数。

def is_called():
    def is_returned():
        print("Hello")
    return is_returned


new = is_called()

# Outputs "Hello"
new()

输出

Hello

这里，is_returned() 是一个嵌套函数，每次调用 is_called() 时都会定义并返回 .

最后，我们必须了解 Python 中的闭包。

回到装饰器

函数和方法被称为callable 因为它们可以被调用。

事实上，任何实现特殊 __call__() 的对象方法称为可调用的。所以，从最基本的意义上来说，装饰器就是一个返回可调用对象的可调用对象。

基本上，装饰器接受一个函数，添加一些功能并返回它。

def make_pretty(func):
    def inner():
        print("I got decorated")
        func()
    return inner


def ordinary():
    print("I am ordinary")

当你在 shell 中运行以下代码时，

>>> ordinary()
I am ordinary

>>> # let's decorate this ordinary function
>>> pretty = make_pretty(ordinary)
>>> pretty()
I got decorated
I am ordinary

在上面显示的示例中，make_pretty() 是一名装饰师。在赋值步骤中：

pretty = make_pretty(ordinary)

函数 ordinary() 被装饰并且返回的函数被命名为 pretty .

我们可以看到装饰器函数在原始函数的基础上增加了一些新功能。这类似于包装礼物。装饰器充当包装器。被装饰的物品（里面的实际礼物）的性质不会改变。但是现在，它看起来很漂亮（因为它被装饰了）。

通常，我们装饰一个函数并将其重新赋值为，

ordinary = make_pretty(ordinary).

这是一个常见的结构，因此，Python 有一种语法来简化它。

我们可以使用 @ 符号连同装饰器函数的名称，并将其放在要装饰的函数的定义之上。例如，

@make_pretty
def ordinary():
    print("I am ordinary")

相当于

def ordinary():
    print("I am ordinary")
ordinary = make_pretty(ordinary)

这只是实现装饰器的语法糖。

带参数的装饰函数

上面的装饰器很简单，它只适用于没有任何参数的函数。如果我们的函数接受以下参数会怎样：

def divide(a, b):
    return a/b

这个函数有两个参数，a 和 b .我们知道如果我们传入 b 会报错为0。

>>> divide(2,5)
0.4
>>> divide(2,0)
Traceback (most recent call last):
...
ZeroDivisionError: division by zero

现在让我们做一个装饰器来检查这种会导致错误的情况。

def smart_divide(func):
    def inner(a, b):
        print("I am going to divide", a, "and", b)
        if b == 0:
            print("Whoops! cannot divide")
            return

        return func(a, b)
    return inner


@smart_divide
def divide(a, b):
    print(a/b)

这个新的实现将返回 None 如果出现错误情况。

>>> divide(2,5)
I am going to divide 2 and 5
0.4

>>> divide(2,0)
I am going to divide 2 and 0
Whoops! cannot divide

通过这种方式，我们可以装饰带参数的函数。

敏锐的观察者会注意到嵌套 inner() 的参数装饰器内部的函数与其装饰的函数的参数相同。考虑到这一点，现在我们可以制作适用于任意数量参数的通用装饰器。

在 Python 中，这个魔法是作为 function(*args, **kwargs) 完成的 .这样，args 将是位置参数和 kwargs 的元组将是关键字参数的字典。这种装饰器的一个例子是：

def works_for_all(func):
    def inner(*args, **kwargs):
        print("I can decorate any function")
        return func(*args, **kwargs)
    return inner

Python 中的链式装饰器

在 Python 中可以链接多个装饰器。

也就是说，一个函数可以用不同（或相同）的装饰器进行多次装饰。我们只需将装饰器放在所需的函数之上即可。

def star(func):
    def inner(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return inner


def percent(func):
    def inner(*args, **kwargs):
        print("%" * 30)
        func(*args, **kwargs)
        print("%" * 30)
    return inner


@star
@percent
def printer(msg):
    print(msg)


printer("Hello")

输出

******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Hello
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************

上面的语法，

@star
@percent
def printer(msg):
    print(msg)

相当于

def printer(msg):
    print(msg)
printer = star(percent(printer))

我们链接装饰器的顺序很重要。如果我们把顺序颠倒为，

@percent
@star
def printer(msg):
    print(msg)

输出将是：

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************
Hello
******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Python 闭包 Python @property 装饰器

Python