Reihenfolge der Python-Dekorateure

1. Reihenfolge der Python-Dekorateure
2. Voraussetzungen für die Decorator-Reihenfolge in Python
3. Syntax von @decorator in Python
4. Wie die Decorator-Reihenfolge in Python bestimmt wird
5. Dekorateur @decorator Bestellung in Python
6. Zwei verschiedene Arten von Dekorateuren in Python

In diesem Python-Artikel werden wir uns ansehen, was Decorators sind, wie sie verwendet werden und wie wir sie zum Erstellen von Code verwenden können. Wir werden sehen, dass ein Decorator ein starkes Werkzeug ist, mit dem wir unseren Anwendungen Funktionalität hinzufügen können und das in der Programmiersprache Python zu finden ist.

Reihenfolge der Python-Dekorateure

In Python ist ein Decorator eine spezielle Funktion, die das Verhalten einer anderen Funktion modifiziert. Der Decorator ist ein Entwurfsmuster, das einem vorhandenen Objekt neue Funktionen hinzufügt, ohne seine Struktur zu ändern, und normalerweise aufgerufen wird, bevor eine Funktion oder Klasse definiert wird.

Decorators in Python sind ein mächtiges Werkzeug zum Modifizieren von Funktionen und Klassen. Ein Decorator ist eine Funktion, die eine andere Funktion als Argument akzeptiert und eine neue Funktion zurückgibt, die die ursprüngliche Funktion umschließt.

Es kann auch verwendet werden, um das Verhalten einer Funktion zu ändern, ohne den Code der Funktion selbst zu ändern. Dies ist nützlich, um Features zu vorhandenen Funktionen hinzuzufügen oder das Verhalten einer Funktion in einem bestimmten Kontext zu ändern.

Dekorateure werden häufig verwendet, um Funktionen zu implementieren wie:

1. Caching
2. Protokollierung
3. Zugangskontrolle

Voraussetzungen für die Decorator-Reihenfolge in Python

Wir müssen ein grundlegendes Verständnis von Python haben, bevor wir etwas über Dekorateure lernen können.

Wir müssen uns damit abfinden, dass alles in Python als Objekte betrachtet wird, sogar Klassen. Die Namen, die wir diesen Dingen geben, sind nur damit verbundene Identifikatoren.

Hier gibt es keine Ausnahmen; Funktionen werden ebenfalls als Objekte (mit Attributen) betrachtet. Mehrere unterschiedliche Namen können an ein einzelnes Funktionsobjekt gebunden werden.

Wir müssen also über folgende Grundkenntnisse verfügen:

1. Python-Programmiersprache
2. Funktionen
3. Klassen

Dann können wir problemlos mit Decorator-Aufträgen in Python arbeiten.

Syntax von @decorator in Python

Der nächste Schritt besteht darin, sich die Syntax von Pythons Decorators anzusehen und zu fragen: Wie bestimmt Python die Reihenfolge, in der Decorators interpretiert werden?

Beispielcode:

@mydecorator
def my_function():
    pass

Das ist also die Syntax eines Decorators in Python. Wir werden Decorators mit Funktionen und Klassen mit der gleichen Syntax verwenden.

Wie die Decorator-Reihenfolge in Python bestimmt wird

Wenn zahlreiche Dekorateure auf eine Funktion oder Klasse angewendet werden, werden die Dekorateure in der Reihenfolge verwendet, in der sie erstellt wurden. dies kann zu unerwartetem Verhalten führen. Wir müssen diese Tatsache im Hinterkopf behalten, da die Reihenfolge, in der Dekorateure angewendet werden, das Verhalten einer Funktion oder Klasse beeinflussen kann.

Es ist wichtig, sich daran zu erinnern, dass die Reihenfolge, in der Dekorateure angewendet werden, den Betrieb der Klasse oder Funktion beeinflussen kann. Wenn mehrere Dekorateure auf eine Komponente gesetzt werden, werden die Dekorateure in der Reihenfolge platziert, in der sie deklariert wurden.

Dekorateur @decorator Bestellung in Python

In Python werden Decorators normalerweise als Funktionen implementiert, die eine Funktion als Argument annehmen und eine modifizierte Funktion zurückgeben. Zum Beispiel können wir den folgenden Dekorateur betrachten.

Führen Sie die folgenden Schritte aus, um den Code zu schreiben:

Beispielcode:

def decorator(func):
    def wrapper(x):
        print("Before calling ", func.__name__)
        result = func(x)
        print("After calling ", func.__name__)
        return result

    return wrapper


@decorator
def foo(x):
    return x + 1


print(foo(2))

Hier drucken wir einfach, um die Ausgabe unseres gesamten Codes zu sehen.

Die Ausgabe des Codes:

Before calling  foo
After calling  foo
3

Wir können sehen, dass die erste Anweisung gedruckt wird: (Before calling foo). Die zweite Anweisung im Code (After calling foo) wird als zweites ausgegeben.

Und der decorator-Teil wird am Ende gedruckt, was x+1 ist, weil wir den Wert 2 für den Parameterwert des Decorators übergeben haben. Und wir haben als Ergebnis 3 bekommen.

Jetzt werden wir uns einen anderen Code ansehen, um die Dekorateure besser zu verstehen.

Wir haben also bereits die Schritte zum Definieren von Funktionen und Dekorateuren durchlaufen. Wir werden wieder die gleichen Schritte gemäß unseren Anforderungen durchführen.

Angenommen, wir möchten in diesem Code, dass der Teil decorator vor der zweiten Anweisung der verschachtelten Funktion ausgeführt wird. Also werden wir den folgenden Code verwenden.

Beispielcode:

def my_decorator(func):
    def wrapper():
        print("Before the function is called.")
        func()
        print("After the function is called.")

    return wrapper


@my_decorator
def say_hello():
    print("Hello, Abid!")


say_hello()

Die Ausgabe des Codes:

Before the function is called.
Hello, Abid!
After the function is called.

Hier können wir sehen, dass Bevor die Funktion aufgerufen wird. wird zuerst gedruckt. Hallo Abid! der Decorator-Teil wird als zweites gedruckt, und das Nach dem Aufruf der Funktion. wird am Ende gedruckt.

Zwei verschiedene Arten von Dekorateuren in Python

Nun werden wir sehen, wie zwei verschiedene Decorator-Funktionen auf die Methode num() angewendet werden können. Der innere Dekorateur wird zuerst arbeiten, gefolgt vom äußeren Dekorateur nach einer kurzen Pause.

Beispielcode:

# code for testing decorator chaining
def decorator1(function):
    def inner():
        a = function()
        return a + a

    return inner


def decorator(function):
    def inner():
        a = function()
        return 4 * a

    return inner


@decorator1
@decorator
def num():
    return 10


print(num())

Die Ausgabe des Codes:

80

Im obigen Beispiel hat also zuerst der innere Dekorateur gearbeitet und danach der äußere. Und daher erhalten wir die Ausgabe des Codes 80.

Die Reihenfolge, in der Decorators angewendet werden, kann wichtig sein. Im Allgemeinen sollten wir Dekoratoren auf Funktionen und Klassen in der Reihenfolge anwenden, in der sie aufgerufen werden.

In Klassen verwendete Dekoratoren sollten jedoch immer angewendet werden, bevor Dekoratoren auf Funktionen angewendet werden.