Wir nennen den Codeausschnitt, der in eine bestimmte Methode einer bestimmten Klasse einschneidet, einen Aspekt, und die Klassen und Methoden, in die eingeschnitten wird, werden als Einstiegspunkte bezeichnet. Auf diese Weise können wir den Code, der mehreren Klassen gemeinsam ist, in ein Segment extrahieren und ihn dann bei Bedarf in das Objekt schneiden, wodurch sein ursprüngliches Verhalten geändert wird.
Diese Denkweise kann die ursprüngliche Codelogik klarer machen und den Originalcode nicht beeinträchtigen. Sie wird häufig für die Berechtigungsverwaltung, Protokollierung, Transaktionsverwaltung usw. verwendet.
Der Dekorator in Python ist ein sehr bekanntes Design und wird häufig in Szenarien mit Aspektanforderungen verwendet.
Django verwendet beispielsweise eine große Anzahl von Dekoratoren, um verschiedene Aspekte von Anforderungen zu erfüllen, wie z. B. Berechtigungskontrolle, Inhaltsfilterung, Anforderungsverwaltung usw.
Dekorator
Python-Dekoratoren (funktionale Dekoratoren) sind Funktionen, mit denen die Funktionen der ursprünglichen Funktion erweitert werden. Der Zweck besteht darin, der Funktion neue Funktionen hinzuzufügen, ohne den ursprünglichen Funktionsnamen oder Klassennamen zu ändern.Kommen Sie mit, um mehr über die Arbeitsweise von Dekorateuren zu erfahren.
Zunächst müssen wir ein Konzept klären: Alles in Python ist ein Objekt und Funktionen sind auch Objekte!
So kann eine Funktion als Objekt in einer anderen Funktion definiert werden. Schauen Sie sich das folgende Beispiel an:
def a():
def b():
print("I'm b")
b()
c = b
return c
d = a()
d()
b()
c()I'm b
I'm bWie aus dem Obigen ersichtlich ist, sind Funktionen Objekte, also:throws NameError: name 'b' is not definiert Error
throws NameError: name 'c' is not definierter Fehler
return</ code> kann ein Funktionsobjekt zurückgeben. Dieses Funktionsobjekt wird innerhalb einer anderen Funktion definiert. Aufgrund unterschiedlicher Gültigkeitsbereiche kann nur die von <code>return zurückgegebene Funktion aufgerufen werden und die Funktionen b und c in der Funktion <code>a</code definiert und zugewiesen werden > kann aufgerufen werden kann nicht im externen Bereich aufgerufen werden. Das bedeutet, dass eine Funktion eine andere Funktion zurückgeben kann. 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
Zusätzlich zur Rückgabe als Objekt kann ein Funktionsobjekt auch als Parameter an eine andere Funktion übergeben werden:
def c(func):
def b():
print('在函数执行前，做一些操作')
result = func()
print("在函数执行后，做一些操作")
return result
return b
@c
def a():
print("函数执行中。。。")
return "I'm a"
print(a())Ausgabeergebnis:
Ich bin bIch bin ein
🎜Funktionsdekorator🎜🎜Wenn wir beispielsweise vor und nach der Ausführung der Funktion einige andere Operationen ausführen möchten, können wir sie gemäß der obigen Funktion als Parameter übergeben. Siehe Folgendes Beispiel: 🎜
OK, jetzt können wir basierend auf diesen Merkmalen der Funktion einen Dekorator erstellen, um die Funktion zu implementieren, ohne die ursprüngliche Funktion zu ändern.🎜🎜Ausgabeergebnis: 🎜🎜🎜🎜Bevor die Funktion ausgeführt wird, führen Sie einige Operationen aus🎜Ich bin ein🎜Nachdem die Funktion ausgeführt wurde, führen Sie einige Operationen aus🎜🎜🎜Aber in diesem Fall wird die ursprüngliche Funktion zu einer anderen Jedes Mal, wenn eine Funktion hinzugefügt wird, erfordert das Einschließen einer neuen Funktion alle Änderungen am ursprünglichen Aufrufort. Dies ist offensichtlich unpraktisch, daher frage ich mich, ob es eine Möglichkeit gibt, die Funktion der Funktion zu ändern, ohne den Namen zu ändern und kann weiterhin als Originalfunktion verwendet werden. 🎜🎜🎜Sehen Sie sich das folgende Beispiel an: 🎜🎜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))Nach dem Login kopierenNach dem Login kopieren🎜🎜Ausgabeergebnis: 🎜🎜🎜🎜Bevor die Funktion ausgeführt wird, führen Sie einige Operationen aus🎜Ich bin ein🎜Nachdem die Funktion ausgeführt wurde, führen Sie einige Operationen aus🎜🎜🎜Wie oben können wir die Funktion „Eine weitere Ebene umwickeln“ verwenden und die neue Funktiondef 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))Nach dem Login kopierenNach dem Login kopierenbals Objekt zurückgeben. Auf diese Weise wird durch die Funktioncageändert undaneu zugewiesen, wodurch die Änderungsfunktiona</code realisiert wird >, Und verwenden Sie auch die Funktion <code>azum Aufrufen. 🎜🎜Aber das Schreiben ist sehr umständlich, da eine Neuzuweisung erforderlich ist. In Python kann dies also über@erreicht werden und die Funktion wird als Parameter übergeben. 🎜🎜🎜Sehen Sie sich das Beispiel an: 🎜🎜🎜🎜 Ausgabeergebnis: 🎜🎜🎜🎜Bevor die Funktion ausgeführt wird, führen Sie einige Operationen aus🎜Ich bin ein🎜Nachdem die Funktion ausgeführt wurde, führen Sie einige Operationen aus🎜🎜🎜Wie oben, Wenn Siedef 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__)Nach dem Login kopierenNach dem Login kopieren@cübergeben, können Sie die Funktionaals Parameter übergeben,cübergeben und die zurückgegebene Funktion als Funktionwiederverwenden a. Diesescist nur ein einfacher Funktionsdekorator. 🎜🎜🎜Und wenn die Funktion einen Rückgabewert hat, muss die geänderte Funktion auch einen Rückgabewert haben, wie folgt: 🎜🎜🎜🎜Ausgabeergebnis: 🎜🎜🎜🎜Bevor die Funktion ausgeführt wird, führen Sie einige Operationen aus🎜Die Funktion wird ausgeführt. . . 🎜Nachdem die Funktion ausgeführt wurde, führen Sie einige Operationen aus🎜Ich bin ein🎜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__)Nach dem Login kopierenNach dem Login kopieren
如上所示：通过将返回值进行传递，就可以实现函数执行前后的操作。但是你会发现一个问题，就是为什么输出 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
在函数装饰器方面，很多人搞不清楚，是因为装饰器可以用函数实现（像上面），也可以用类实现。因为函数和类都是对象，同样可以作为被装饰的对象，所以根据被装饰的对象不同，一同有下面四种情况：
函数装饰函数
类装饰函数
函数装饰类
类装饰类
下面我们依次来说明一下这四种情况的使用。
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 'function'>此为最常见的装饰器，用于装饰函数，返回的是一个函数。
也就是通过类来实现装饰器的功能而已。通过类的 __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 'function'>以上所示，只是将用函数定义的装饰器改为使用类来实现而已。还是用于装饰函数，因为在类的 __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 'function'>如上是比较方便简答的，使用类定义函数装饰器，且返回对象为函数，元数据保留。
下面重点来啦，我们常见的装饰器都是用于装饰函数的，返回的对象也是一个函数，而要装饰类，那么返回的对象就要是类，且类的元数据等也要保留。
不怕丢脸的说，目前我还不知道怎么实现完美的类装饰器，在装饰类的时候，一般有两种方法：
返回一个函数，实现类在创建实例的前后执行操作，并正常返回此类的实例。但是这样经过装饰器的类就属于函数了，其无法继承，但可以正常调用创建实例。
如下：
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 '__main__.A'>
<class 'function'>如上所示，就是第一种方法。
接上文，返回一个类，实现类在创建实例的前后执行操作，但类已经改变了，创建的实例也已经不是原本类的实例了。
看下面示例：
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 的属性，但是类的元数据无法改变。很多内置的方法也就会有问题。我个人是不推荐这种做法的！
所以，我推荐在代码中，尽量避免类装饰器的使用，如果要在类中做一些操作，完全可以通过修改类的魔法方法，继承，元类等等方式来实现。如果避免不了，那也请谨慎处理。
Das obige ist der detaillierte Inhalt vonWie man aspektorientierte Programmierung AOP und Dekoratoren in Python verwendet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
