Wprowadzenie do dekoratorów

Dekoratory to zaawansowana funkcja języka Python, która umożliwia modyfikowanie działania funkcji lub metod. Często używa się ich do dodawania funkcjonalności do funkcji bez modyfikowania ich kodu.

W tej lekcji dowiedzą się Państwo, czym są dekoratory, jak ich używać oraz jak tworzyć własne dekoratory.

Czym jest dekorator?

Dekorator to funkcja, która przyjmuje inną funkcję jako dane wejściowe i zwraca nową funkcję z dodaną funkcjonalnością. Często używa się go wraz ze składnią @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()

Jak działają dekoratory

Po użyciu dekoratora Python zastępuje oryginalną funkcję funkcją opakowującą zwróconą przez dekorator.

# 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()

Używanie dekoratorów z argumentami

Dekoratory mogą współpracować z funkcjami przyjmującymi argumenty dzięki użyciu *args i **kwargs w funkcji opakowującej:

# 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))

Łączenie wielu dekoratorów

Na jednej funkcji można użyć wielu dekoratorów. Są one stosowane w kolejności, w której występują, od góry do dołu:

# 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()

Tworzenie dekoratorów przyjmujących parametry

Dekoratory przyjmujące parametry pozwalają przekazywać argumenty, zapewniając większą elastyczność działania:

# 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()

Typowe zastosowania dekoratorów

Dekoratory są często używane do:

• Rejestrowania wywołań funkcji i przekazywanych do nich argumentów.
• Mierzenia czasu wykonywania funkcji.
• Kontroli dostępu (np. sprawdzania uprawnień użytkowników).
• Cachowania wyników w celu zwiększenia wydajności.

Wbudowane dekoratory w Pythonie

Python udostępnia kilka wbudowanych dekoratorów, w tym:

• @staticmethod: Definiuje metodę statyczną.
• @classmethod: Definiuje metodę klasową.
• @property: Definiuje właściwość.

Typowe błędy dotyczące dekoratorów

Oto kilka błędów, których należy unikać:

• Niezachowywanie nazwy i docstringa oryginalnej funkcji (należy użyć functools.wraps).
• Niepotrzebne używanie dekoratorów do prostych zadań.
• Zapominanie o obsłudze argumentów w funkcji opakowującej.

Czego się nauczyliśmy?

W tej lekcji nauczyli się Państwo:

• Czym są dekoratory i jak działają w języku Python.
• Jak tworzyć i używać podstawowych, sparametryzowanych oraz łańcuchowych dekoratorów.
• Jakie są typowe zastosowania i wbudowane dekoratory w języku Python.

Świetna praca! Przejdźmy do następnego tematu.