Dekoratorer

Dekoratorer är en kraftfull funktion i Python som gör att du kan ändra funktioners eller metoders beteende. De används ofta för att lägga till funktionalitet i funktioner utan att ändra deras kod.

I den här lektionen får du lära dig vad dekoratorer är, hur du använder dem och hur du skapar egna dekoratorer.

En dekorator är en funktion som tar en annan funktion som indata och returnerar en ny funktion med utökad funktionalitet. Den används ofta tillsammans med syntaxen @decorator_name.

# Basic example of a decorator
def decorator(func):
    def wrapper():
        print("Before the function call")
        func()
        print("After the function call")
    return wrapper

@decorator
def say_hello():
    print("Hello!")

say_hello()

När du använder en dekorator ersätter Python den ursprungliga funktionen med den wrapper-funktion som dekoratorn returnerar.

# How decorators work
def decorator(func):
    def wrapper():
        print("Wrapper called")
        func()
    return wrapper

@decorator
def greet():
    print("Greetings!")

print(greet.__name__)  # Outputs: wrapper
greet()

Dekoratorer kan fungera med funktioner som tar argument genom att använda *args och **kwargs i wrapper-funktionen:

# Decorator for functions with arguments
def decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Arguments: {args}, {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@decorator
def add(a, b):
    return a + b

print(add(3, 5))

Du kan använda flera dekoratorer på en och samma funktion. De tillämpas i den ordning de visas, uppifrån och ned:

# Chaining multiple decorators
def decorator1(func):
    def wrapper():
        print("Decorator 1")
        func()
    return wrapper

def decorator2(func):
    def wrapper():
        print("Decorator 2")
        func()
    return wrapper

@decorator1
@decorator2
def greet():
    print("Hello!")

greet()

Parametriserade dekoratorer tar argument och möjliggör mer flexibel funktionalitet:

# Parameterized decorator
def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()

Dekoratorer används ofta för:

• Loggning av funktionsanrop och deras argument.
• Mätning av funktioners körtid.
• Åtkomstkontroll (t.ex. kontroll av användarbehörigheter).
• Cachelagring av resultat för bättre prestanda.

Python innehåller flera inbyggda dekoratorer, bland annat:

• @staticmethod: Definierar en statisk metod.
• @classmethod: Definierar en klassmetod.
• @property: Definierar en property-metod.

Här är några misstag du bör undvika:

• Att inte bevara den ursprungliga funktionens namn och docstring (använd functools.wraps).
• Att använda dekoratorer i onödan för enkla uppgifter.
• Att glömma att hantera argument i wrapper-funktionen.

I den här lektionen har du lärt dig:

• Vad dekoratorer är och hur de fungerar i Python.
• Hur du skapar och använder grundläggande, parametriserade och kedjade dekoratorer.
• Vanliga användningsområden för och inbyggda dekoratorer i Python.

Bra jobbat! Nu går vi vidare till nästa ämne.