Comment utiliser la programmation orientée aspect AOP et les décorateurs en Python

Qu'est-ce que l'AOP

AOP est une programmation orientée aspect. En termes simples, l'idée de programmation consistant à découper dynamiquement le code en méthodes spécifiées et en positions spécifiées d'une classe est une programmation orientée aspect.

Nous appelons l'extrait de code qui coupe dans une méthode spécifiée d'une classe spécifiée comme un aspect, et les classes et méthodes dans lesquelles sont coupées sont appelées points d'entrée. De cette façon, nous pouvons extraire le code commun à plusieurs classes dans une tranche, puis découper l'objet lorsque cela est nécessaire, modifiant ainsi son comportement d'origine.

Ce type de réflexion peut rendre la logique du code d'origine plus claire et non invasive par rapport au code d'origine. Il est souvent utilisé pour la gestion des autorisations, la journalisation, la gestion des transactions, etc.

Le décorateur en Python est un design très célèbre et est souvent utilisé dans des scénarios avec des exigences d'aspect.

Par exemple, Django utilise un grand nombre de décorateurs pour compléter divers aspects des exigences, tels que le contrôle des autorisations, le filtrage de contenu, la gestion des demandes, etc.

Decorator

Les décorateurs Python (décorateurs fonctionnels) sont des fonctions utilisées pour étendre les fonctionnalités de la fonction d'origine. Le but est d'ajouter de nouvelles fonctions à la fonction sans changer le nom de la fonction d'origine ou le nom de la classe.

Venez avec moi pour en savoir plus sur le fonctionnement des décorateurs.

Tout d'abord, nous devons clarifier un concept : tout en Python est un objet, et les fonctions sont aussi des objets !

Ainsi, une fonction en tant qu'objet peut être définie dans une autre fonction. Regardez l'exemple suivant :

def a():
    def b():
        print("I'm b")
    b()
    c = b
    return c
d = a()
d()
b()
c()

Le résultat de sortie est :

I'm b
I'm b
throws NameError : le nom 'b' n'est pas défini Error
throws NameError : le nom 'c' n'est pas défini Erreur définie

Comme on peut le voir ci-dessus, puisque les fonctions sont des objets, donc :

• peut être assigné à des variables

• peut être défini dans une autre fonction

Ensuite, return code> peut renvoyer un objet fonction. Cet objet fonction est défini dans une autre fonction. En raison de portées différentes, seule la fonction renvoyée par <code>return peut être appelée, et les fonctions b et c définies et affectées dans la fonction <code>a ne peut pas être appelé dans une portée externe. return 可以返回一个函数对象。这个函数对象是在另一个函数中定义的。由于作用域不同，所以只有 return 返回的函数可以调用，在函数 a 中定义和赋值的函数 b 和 c 在外部作用域是无法调用的。

这意味着一个功能可以 return 另一个功能。

除了可以作为对象返回外，函数对象还可以作为参数传递给另一个函数：

def a():
    print("I'm a")
def b(func):
    print("I'm b")
    func()
b(a)

 输出结果：

I'm b
I'm a

OK，现在，基于函数的这些特性，我们就可以创建一个装饰器，用来在不改变原函数的情况下，实现功能。

函数装饰器

比如，我们要在函数执行前和执行后分别执行一些别的操作，那么根据上面函数可以作为参数传递，我们可以这样实现，看下面示例：

def a():
    print("I'm a")
def b(func):
    print('在函数执行前，做一些操作')
    func()
    print("在函数执行后，做一些操作")
b(a)

输出结果：

在函数执行前，做一些操作
I'm a
在函数执行后，做一些操作

但是这样的话，原函数就变成了另一个函数，每加一个功能，就要在外面包一层新的函数，这样原来调用的地方，就会需要全部修改，这明显不方便，就会想，有没有办法可以让函数的操作改变，但是名称不改变，还是作为原函数呢。

看下面示例：

def a():
    print("I'm a")

def c(func):
    def b():
        print('在函数执行前，做一些操作')
        func()
        print("在函数执行后，做一些操作")
    return b

a = c(a)
a()

输出结果：

在函数执行前，做一些操作
I'm a
在函数执行后，做一些操作

如上，我们可以将函数再包一层，将新的函数 b，作为对象返回。这样通过函数 c，将 a 改变并重新赋值给 a，这样就实现了改变函数 a，并同样使用函数 a 来调用。

但是这样写起来非常不方便，因为需要重新赋值，所以在 Python 中，可以通过 @ 来实现，将函数作为参数传递。

看下示例：

def c(func):
    def b():
        print('在函数执行前，做一些操作')
        func()
        print("在函数执行后，做一些操作")
    return b
@c
def a():
    print("I'm a")
a()

 输出结果：

在函数执行前，做一些操作
I'm a
在函数执行后，做一些操作

如上，通过 @c，就实现了将函数 a 作为参数，传入 c，并将返回的函数重新作为函数 a。这 c

Cela signifie qu'une fonction peut retourner une autre fonction.

En plus d'être renvoyé en tant qu'objet, un objet fonction peut également être passé en paramètre à une autre fonction :

def c(func):
    def b():
        print('在函数执行前，做一些操作')
        result = func()
        print("在函数执行后，做一些操作")
        return result
    return b
@c
def a():
    print("函数执行中。。。")
    return "I'm a"
print(a())

Résultat de sortie :

Je suis b
Je suis un

🎜 OK, maintenant, sur la base de ces caractéristiques de la fonction, nous pouvons créer un décorateur pour implémenter la fonction sans modifier la fonction d'origine. 🎜🎜Function Decorator🎜🎜Par exemple, si nous voulons effectuer d'autres opérations avant et après l'exécution de la fonction, alors selon la fonction ci-dessus, elle peut être passée en paramètre. Nous pouvons l'implémenter comme ceci, voir ce qui suit. exemple : 🎜

def c(func):
    def b(name, age):
        print('在函数执行前，做一些操作')
        result = func(name, age)
        print("在函数执行后，做一些操作")
        return result
    return b
@c
def a(name, age):
    print("函数执行中。。。")
    return "我是 {}, 今年{}岁 ".format(name, age)
print(a('Amos', 24))

🎜🎜Résultat de sortie : 🎜🎜🎜🎜Avant que la fonction ne soit exécutée, effectuez quelques opérations🎜Je suis un🎜Après l'exécution de la fonction, effectuez quelques opérations🎜🎜🎜Mais dans ce cas, la fonction d'origine devient une autre fonction. Chaque fois qu'une fonction est ajoutée, envelopper une nouvelle fonction à l'extérieur nécessitera toutes les modifications du lieu d'appel d'origine, ce qui est évidemment gênant, donc je me demande s'il existe un moyen de modifier le fonctionnement de la fonction, mais pas de le changer. le nom, tout en l'utilisant comme fonction d'origine. 🎜🎜🎜Regardez l'exemple ci-dessous : 🎜🎜

def c(func):
    def b(*args, **kwargs):
        print('在函数执行前，做一些操作')
        result = func(*args, **kwargs)
        print("在函数执行后，做一些操作")
        return result
    return b
@c
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)
@c
def d(sex, height):
    print('函数执行中。。。')
    return '性别：{}，身高：{}'.format(sex, height)
print(a('Amos', 24))
print(d('男', 175))

🎜🎜Résultat de sortie : 🎜🎜🎜🎜Avant l'exécution de la fonction, effectuez quelques opérations🎜Je suis un🎜Après l'exécution de la fonction, effectuez quelques opérations🎜🎜🎜Comme ci-dessus , nous pouvons utiliser la fonction Envelopper un autre calque et renvoyer la nouvelle fonction b en tant qu'objet. De cette façon, grâce à la fonction c, a est modifié et réaffecté à a, réalisant ainsi la fonction de changement a, Et utilisez également la fonction a pour appeler. 🎜🎜Mais c'est très gênant à écrire car cela nécessite une réaffectation, donc en Python, cela peut être réalisé via @ et la fonction est passée en paramètre. 🎜🎜🎜Regardez l'exemple : 🎜🎜

def c(func):
    def b(*args, **kwargs):
        print('在函数执行前，做一些操作')
        result = func(*args, **kwargs)
        print("在函数执行后，做一些操作")
        return result
    return b
@c
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)
print(a.__name__)

🎜🎜 Résultat de sortie : 🎜🎜🎜🎜Avant l'exécution de la fonction, effectuez quelques opérations🎜Je suis un🎜Après l'exécution de la fonction, effectuez quelques opérations🎜🎜🎜Comme ci-dessus, passez @c, vous pouvez passer la fonction a en tant que paramètre, passer c et réutiliser la fonction renvoyée en tant que fonction un . Ce c n'est qu'un simple décorateur de fonctions. 🎜🎜🎜Et si la fonction a une valeur de retour, alors la fonction modifiée doit également avoir une valeur de retour, comme suit : 🎜🎜

from functools import wraps
def c(func):
    @wraps(func)
    def b(*args, **kwargs):
        print('在函数执行前，做一些操作')
        result = func(*args, **kwargs)
        print("在函数执行后，做一些操作")
        return result
    return b
@c
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)
print(a.__name__)

🎜🎜Résultat de sortie : 🎜🎜🎜🎜Avant que la fonction ne soit exécutée, effectuez quelques opérations🎜Le la fonction est en cours d'exécution. . . 🎜Une fois la fonction exécutée, effectuez quelques opérations🎜Je suis un🎜

如上所示：通过将返回值进行传递，就可以实现函数执行前后的操作。但是你会发现一个问题，就是为什么输出 I'm a 会在最后才打印出来？

因为 I'm a 是返回的结果，而实际上函数是 print("在函数执行后，做一些操作") 这一操作前运行的，只是先将返回的结果给到了 result，然后 result 传递出来，最后由最下方的 print(a()) 打印了出来。

那如何函数 a 带参数怎么办呢？很简单，函数 a 带参数，那么我们返回的函数也同样要带参数就好啦。

看下面示例：

def c(func):
    def b(name, age):
        print('在函数执行前，做一些操作')
        result = func(name, age)
        print("在函数执行后，做一些操作")
        return result
    return b
@c
def a(name, age):
    print("函数执行中。。。")
    return "我是 {}, 今年{}岁 ".format(name, age)
print(a('Amos', 24))

输出结果：

在函数执行前，做一些操作
函数执行中。。。
在函数执行后，做一些操作
我是 Amos, 今年24岁 

但是又有问题了，我写一个装饰器 c，需要装饰多个不同的函数，这些函数的参数各不相同，那么怎么办呢？简单，用 *args 和 **kwargs 来表示所有参数即可。

如下示例：

def c(func):
    def b(*args, **kwargs):
        print('在函数执行前，做一些操作')
        result = func(*args, **kwargs)
        print("在函数执行后，做一些操作")
        return result
    return b
@c
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)
@c
def d(sex, height):
    print('函数执行中。。。')
    return '性别：{}，身高：{}'.format(sex, height)
print(a('Amos', 24))
print(d('男', 175))

输出结果：

在函数执行前，做一些操作
函数执行中。。。
在函数执行后，做一些操作
我是 Amos, 今年24岁 

在函数执行前，做一些操作
函数执行中。。。
在函数执行后，做一些操作
性别：男，身高：175

如上就解决了参数的问题，哇，这么好用。那是不是这样就没有问题了？并不是！经过装饰器装饰后的函数，实际上已经变成了装饰器函数 c 中定义的函数 b，所以函数的元数据则全部改变了！

如下示例：

def c(func):
    def b(*args, **kwargs):
        print('在函数执行前，做一些操作')
        result = func(*args, **kwargs)
        print("在函数执行后，做一些操作")
        return result
    return b
@c
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)
print(a.__name__)

输出结果：

b

会发现函数实际上是函数 b 了，这就有问题了，那么该怎么解决呢，有人就会想到，可以在装饰器函数中先把原函数的元数据保存下来，在最后再讲 b 函数的元数据改为原函数的，再返回 b。这样的确是可以的！但我们不这样用，为什么？

因为 Python 早就想到这个问题啦，所以给我们提供了一个内置的方法，来自动实现原数据的保存和替换工作。哈哈，这样就不同我们自己动手啦！

看下面示例：

from functools import wraps
def c(func):
    @wraps(func)
    def b(*args, **kwargs):
        print('在函数执行前，做一些操作')
        result = func(*args, **kwargs)
        print("在函数执行后，做一些操作")
        return result
    return b
@c
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)
print(a.__name__)

输出结果：

a

使用内置的 wraps 装饰器，将原函数作为装饰器参数，实现函数原数据的保留替换功能。

耶！装饰器还可以带参数啊，你看上面 wraps 装饰器就传入了参数。哈哈，是的，装饰器还可以带参数，那怎么实现呢？

看下面示例：

from functools import wraps
def d(name):
    def c(func):
        @wraps(func)
        def b(*args, **kwargs):
            print('装饰器传入参数为：{}'.format(name))
            print('在函数执行前，做一些操作')
            result = func(*args, **kwargs)
            print("在函数执行后，做一些操作")
            return result
        return b
    return c
@d(name='我是装饰器参数')
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)

print(a('Amos', 24))

输出结果：

装饰器传入参数为：我是装饰器参数
在函数执行前，做一些操作
函数执行中。。。
在函数执行后，做一些操作
我是 Amos, 今年24岁 

如上所示，很简单，只需要在原本的装饰器之上，再包一层，相当于先接收装饰器参数，然后返回一个不带参数的装饰器，然后再将函数传入，最后返回变化后的函数。

这样就可以实现很多功能了，这样可以根据传给装饰器的参数不同，来分别实现不同的功能。

另外，可能会有人问， 可以在同一个函数上，使用多个装饰器吗？答案是：可以！

看下面示例：

from functools import wraps
def d(name):
    def c(func):
        @wraps(func)
        def b(*args, **kwargs):
            print('装饰器传入参数为：{}'.format(name))
            print('我是装饰器d: 在函数执行前，做一些操作')
            result = func(*args, **kwargs)
            print("我是装饰器d: 在函数执行后，做一些操作")
            return result
        return b
    return c
def e(name):
    def c(func):
        @wraps(func)
        def b(*args, **kwargs):
            print('装饰器传入参数为：{}'.format(name))
            print('我是装饰器e: 在函数执行前，做一些操作')
            result = func(*args, **kwargs)
            print("我是装饰器e: 在函数执行后，做一些操作")
            return result
        return b
    return c
@e(name='我是装饰器e')
@d(name='我是装饰器d')
def func_a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)

print(func_a('Amos', 24))
行后，做一些操作
我是 Amos, 今年24岁

 输出结果：

装饰器传入参数为：我是装饰器e
我是装饰器e: 在函数执行前，做一些操作

装饰器传入参数为：我是装饰器d
我是装饰器d: 在函数执行前，做一些操作
函数执行中。。。
我是装饰器d: 在函数执行后，做一些操作

我是装饰器e: 在函数执

如上所示，当两个装饰器同时使用时，可以想象成洋葱，最下层的装饰器先包装一层，然后一直到最上层装饰器，完成多层的包装。然后执行时，就像切洋葱，从最外层开始，只执行到被装饰函数运行时，就到了下一层，下一层又执行到函数运行时到下一层，一直到执行了被装饰函数后，就像切到了洋葱的中间，然后再往下，依次从最内层开始，依次执行到最外层。

示例：

当一个函数 a 被 b，c，d 三个装饰器装饰时，执行顺序如下图所示，多个同理。

@d
@c
@b
def a():
    pass

类装饰器

在函数装饰器方面，很多人搞不清楚，是因为装饰器可以用函数实现（像上面），也可以用类实现。因为函数和类都是对象，同样可以作为被装饰的对象，所以根据被装饰的对象不同，一同有下面四种情况：

• 函数装饰函数

• 类装饰函数

• 函数装饰类

• 类装饰类

下面我们依次来说明一下这四种情况的使用。

1、函数装饰函数

from functools import wraps
def d(name):
    def c(func):
        @wraps(func)
        def b(*args, **kwargs):
            print('装饰器传入参数为：{}'.format(name))
            print('在函数执行前，做一些操作')
            result = func(*args, **kwargs)
            print("在函数执行后，做一些操作")
            return result
        return b
    return c
@d(name='我是装饰器参数')
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)

print(a.__class__)
# 输出结果：
<class &#39;function&#39;>

此为最常见的装饰器，用于装饰函数，返回的是一个函数。

2、类装饰函数

也就是通过类来实现装饰器的功能而已。通过类的 __call__ 方法实现：

from functools import wraps
class D(object):
    def __init__(self, name):
        self._name = name
    def __call__(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            print('装饰器传入参数为：{}'.format(self._name))
            print('在函数执行前，做一些操作')
            result = func(*args, **kwargs)
            print("在函数执行后，做一些操作")
            return result
        return wrapper
@D(name='我是装饰器参数')
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)
print(a.__class__)
# 输出结果：
<class &#39;function&#39;>

以上所示，只是将用函数定义的装饰器改为使用类来实现而已。还是用于装饰函数，因为在类的 __call__ 中，最后返回的还是一个函数。

此为带装饰器参数的装饰器实现方法，是通过 __call__ 方法。

若装饰器不带参数，则可以将 __init__ 方法去掉，但是在使用装饰器时，需要 @D() 这样使用，如下：

from functools import wraps
class D(object):
    def __call__(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            print('在函数执行前，做一些操作')
            result = func(*args, **kwargs)
            print("在函数执行后，做一些操作")
            return result
        return wrapper
@D()
def a(name, age):
    print('函数执行中。。。')
    return "我是 {}, 今年{}岁 ".format(name, age)

print(a.__class__)
# 输出结果：
<class &#39;function&#39;>

如上是比较方便简答的，使用类定义函数装饰器，且返回对象为函数，元数据保留。

3、函数装饰类

下面重点来啦，我们常见的装饰器都是用于装饰函数的，返回的对象也是一个函数，而要装饰类，那么返回的对象就要是类，且类的元数据等也要保留。

不怕丢脸的说，目前我还不知道怎么实现完美的类装饰器，在装饰类的时候，一般有两种方法：

返回一个函数，实现类在创建实例的前后执行操作，并正常返回此类的实例。但是这样经过装饰器的类就属于函数了，其无法继承，但可以正常调用创建实例。

如下：

from functools import wraps
def d(name):
    def c(cls):
        @wraps(cls)
        def b(*args, **kwargs):
            print('装饰器传入参数为：{}'.format(name))
            print('在类初始化前，做一些操作')
            instance = cls(*args, **kwargs)
            print("在类初始化后，做一些操作")
            return instance
        return b
    return c
@d(name='我是装饰器参数')
class A(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('类初始化实例，{} {}'.format(self.name, self.age))

a = A('Amos', 24)
print(a.__class__)
print(A.__class__)

# 输出结果：
装饰器传入参数为：我是装饰器参数
在类初始化前，做一些操作
类初始化实例，Amos 24
在类初始化后，做一些操作
<class &#39;__main__.A&#39;>
<class &#39;function&#39;>

如上所示，就是第一种方法。

4、类装饰类

接上文，返回一个类，实现类在创建实例的前后执行操作，但类已经改变了，创建的实例也已经不是原本类的实例了。

看下面示例：

def desc(name):
    def decorator(aClass):
        class Wrapper(object):
            def __init__(self, *args, **kwargs):
                print('装饰器传入参数为：{}'.format(name))
                print('在类初始化前，做一些操作')
                self.wrapped = aClass(*args, **kwargs)
                print("在类初始化后，做一些操作")

            def __getattr__(self, name):
                print('Getting the {} of {}'.format(name, self.wrapped))
                return getattr(self.wrapped, name)

            def __setattr__(self, key, value):
                if key == 'wrapped':  # 这里捕捉对wrapped的赋值
                    self.__dict__[key] = value
                else:
                    setattr(self.wrapped, key, value)

        return Wrapper
    return decorator
@desc(name='我是装饰器参数')
class A(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('类初始化实例，{} {}'.format(self.name, self.age))

a = A('Amos', 24)
print(a.__class__)
print(A.__class__)
print(A.__name__)

输出结果：

装饰器传入参数为：我是装饰器参数
在类初始化前，做一些操作
类初始化实例，Amos 24
在类初始化后，做一些操作
.decorator..Wrapper'>

Wrapper

如上，看到了吗，通过在函数中新定义类，并返回类，这样函数还是类，但是经过装饰器后，类 A 已经变成了类 Wrapper，且生成的实例 a 也是类 Wrapper 的实例，即使通过 __getattr__ 和 __setattr__ 两个方法，使得实例a的属性都是在由类 A 创建的实例 wrapped 的属性，但是类的元数据无法改变。很多内置的方法也就会有问题。我个人是不推荐这种做法的！

所以，我推荐在代码中，尽量避免类装饰器的使用，如果要在类中做一些操作，完全可以通过修改类的魔法方法，继承，元类等等方式来实现。如果避免不了，那也请谨慎处理。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!