Python Dekoratoren: Superkräfte für Ihre Funktionen hinzufügen

Hallo da, aufstrebende Python-Programmierer! Heute tauchen wir in die faszinierende Welt der Python-Dekoratoren ein. Stellen Sie sich Dekoratoren als magische Umhüllungen vor, die Ihren Funktionen Superkräfte verleihen können. Spannend, nicht wahr? Lassen Sie uns gemeinsam auf diese Reise aufbrechen!

Was sind Dekoratoren?

Stellen Sie sich vor, Sie haben ein schön verpacktes Geschenk. Die Verpackungspapier ändert nicht das Geschenk drinnen, aber es sieht doch schöner aus, nicht wahr? Genau das machen Dekoratoren bei Ihren Funktionen in Python. Sie umhüllen Ihre Funktionen, fügen zusätzliche Funktionalität hinzu, ohne die ursprüngliche Funktion selbst zu verändern.

Lassen Sie uns mit einem einfachen Beispiel beginnen:

def mein_dekorator(func):
def umhüllung():
print("Etwas passiert, bevor die Funktion aufgerufen wird.")
func()
print("Etwas passiert, nachdem die Funktion aufgerufen wurde.")
return umhüllung

@mein_dekorator
def sag_hallo():
print("Hallo!")

sag_hallo()

Wenn Sie diesen Code ausführen, sehen Sie:

Etwas passiert, bevor die Funktion aufgerufen wird.
Hallo!
Etwas passiert, nachdem die Funktion aufgerufen wurde.

Lassen Sie uns das aufbrechen:

1. Wir definieren eine Dekorator-Funktion mein_dekorator, die eine Funktion als Argument nimmt.
2. Innerhalb von mein_dekorator definieren wir eine umhüllung-Funktion, die einige Verhaltensweisen vor und nach dem Aufrufen der ursprünglichen Funktion hinzufügt.
3. Wir verwenden die @mein_dekorator-Syntax, um unseren Dekorator auf die sag_hallo-Funktion anzuwenden.
4. Wenn wir sag_hallo() aufrufen, wird tatsächlich die umhüllte Version der Funktion aufgerufen.

Ist das nicht praktisch? Wir haben so unsere sag_hallo-Funktion zusätzliche Verhaltensweisen hinzugefügt, ohne ihren Code zu verändern!

Dekoratoren mit Argumenten

Aber warten Sie, es gibt mehr! Was wenn unsere Funktion Argumente nimmt? Kein Problem! Wir können unseren Dekorator so anpassen, dass er damit umgehen kann:

def mein_dekorator(func):
def umhüllung(*args, **kwargs):
print("Bevor die Funktion aufgerufen wird.")
ergebnis = func(*args, **kwargs)
print("Nachdem die Funktion aufgerufen wurde.")
return ergebnis
return umhüllung

@mein_dekorator
def addieren(a, b):
return a + b

print(addieren(3, 5))

Dies wird ausgeben:

Bevor die Funktion aufgerufen wird.
Nachdem die Funktion aufgerufen wurde.
8

Hier erlauben *args und **kwargs unserem Dekorator, mit jeder beliebigen Anzahl von positionalen und benannten Argumenten zu arbeiten.

Eingebaute Dekoratoren

Python kommt mit einigen eingebauten Dekoratoren, die unglaublich nützlich sind. Lassen Sie uns sie erkunden!

Der @classmethod Dekorator

Der @classmethod-Dekorator wird verwendet, um Methoden zu definieren, die auf die Klasse selbst operieren, anstatt auf Instanzen der Klasse.

class Pizza:
def __init__(self, zutaten):
self.zutaten = zutaten

@classmethod
def margherita(cls):
return cls(['Mozzarella', 'Tomaten'])

@classmethod
def prosciutto(cls):
return cls(['Mozzarella', 'Tomaten', 'Schinken'])

print(Pizza.margherita().zutaten)
print(Pizza.prosciutto().zutaten)

Dies wird ausgeben:

['Mozzarella', 'Tomaten']
['Mozzarella', 'Tomaten', 'Schinken']

Hier sind margherita und prosciutto Klassenmethoden, die neue Pizza-Instanzen mit vordefinierten Zutaten erstellen und zurückgeben.

Der @staticmethod Dekorator

Statische Methoden sind Methoden, die nicht auf die Instanz oder die Klasse operieren. Sie sind nur normale Funktionen, die zufällig in einer Klasse leben.

class Math:
@staticmethod
def addieren(a, b):
return a + b

print(Math.addieren(5, 10))

Dies wird ausgeben:

15

Der @property Dekorator

Der @property-Dekorator ermöglicht es Ihnen, Methoden zu definieren, die Sie wie Attribute ansprechen können.

class Kreis:
def __init__(self, radius):
self._radius = radius

@property
def radius(self):
return self._radius

@property
def fläche(self):
return 3.14 * self._radius ** 2

c = Kreis(5)
print(c.radius)
print(c.fläche)

Dies wird ausgeben:

5
78.5

Hier können wir radius und fläche so ansprechen, als wären es Attribute, aber sie sind tatsächlich Methoden.

Der @functools.wraps Dekorator

Dieser Dekorator wird verwendet, um Metadaten der ursprünglichen Funktion zu erhalten, wenn Dekoratoren erstellt werden.

from functools import wraps

def mein_dekorator(func):
@wraps(func)
def umhüllung(*args, **kwargs):
"""Dies ist die umhüllende Funktion"""
return func(*args, **kwargs)
return umhüllung

@mein_dekorator
def meine_funktion():
"""Dies ist meine Funktion"""
pass

print(meine_funktion.__name__)
print(meine_funktion.__doc__)

Dies wird ausgeben:

meine_funktion
Dies ist meine Funktion

Ohne @wraps wären der Funktionsname und die Dokumentationthose der umhüllenden Funktion.

Fazit

Dekoratoren sind eine leistungsstarke Funktion in Python, die es Ihnen ermöglicht, Funktionen und Methoden zu verändern oder zu erweitern. Sie werden breit in Frameworks und Bibliotheken verwendet, um Funktionalitäten wie Protokollierung, Zugriffskontrolle und mehr hinzuzufügen.

Erinnern Sie sich, der Schlüssel zur Meisterschaft bei Dekoratoren ist Übung. Versuchen Sie, Ihre eigenen Dekoratoren zu erstellen und sie auf verschiedene Funktionen anzuwenden. Bald werden Sie Ihre Funktionen mit Superkräften wie ein Profi umhüllen!

Hier ist eine Tabelle, die die von uns behandelten Dekoratoren zusammenfasst:

Dekorator	Zweck
@classmethod	Methoden definieren, die auf die Klasse selbst operieren
@staticmethod	Methoden definieren, die nicht auf die Instanz oder Klasse operieren
@property	Methoden definieren, die wie Attribute ansprechbar sind
@functools.wraps	Metadaten der ursprünglichen Funktion in Dekoratoren beibehalten

Happy coding, und möge Ihre Funktionen immer schön dekoriert sein!

Credits: Image by storyset