Cum să utilizați decoratorii Python pentru a îmbunătăți funcțiile

Decoratorii Python sunt o modalitate puternică și flexibilă de a modifica sau îmbunătăți funcțiile și metodele. Decoratorii oferă o modalitate de a încheia o funcție cu funcționalitate suplimentară, permițându-vă să extindeți comportamentul acesteia fără a modifica codul real. Acest articol vă va prezenta conceptul de decoratori, cum să le creați și să le utilizați și să explorați câteva exemple practice.

Ce este un Decorator?

Un decorator este o funcție care preia o altă funcție și își extinde comportamentul fără a o modifica în mod explicit. În Python, decoratorii sunt adesea folosiți pentru a adăuga funcționalități precum înregistrarea, controlul accesului sau măsurarea performanței la funcțiile sau metodele existente. Decoratorii sunt aplicați la funcții folosind sintaxa @decorator_name.

# Basic example of a decorator
def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

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

say_hello()

Cum funcționează decoratorii

Când aplicați un decorator unei funcții, Python efectuează în esență următorii pași:

1. Funcția decorator este apelată cu funcția originală ca argument.
2. Funcția decorator definește o nouă funcție (numită adesea wrapper) care îmbunătățește sau modifică comportamentul funcției originale.
3. Funcția decorator returnează noua funcție.
4. Când funcția decorată este apelată, ea apelează de fapt noua funcție returnată de decorator.

Crearea unui decorator simplu

Să creăm un decorator simplu care măsoară timpul de execuție al unei funcții. Acest lucru este util pentru testarea și optimizarea performanței.

import time

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Execution time: {end_time - start_time} seconds")
        return result
    return wrapper

@timing_decorator
def slow_function():
    time.sleep(2)
    print("Function finished!")

slow_function()

Folosirea decoratorilor cu argumente

Uneori, poate doriți să transmiteți argumente decoratorului dvs. Pentru a realiza acest lucru, trebuie să creați o fabrică de decoratori - o funcție care returnează un decorator. Iată un exemplu de decorator care ia un argument pentru a specifica un mesaj personalizat.

def custom_message_decorator(message):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(message)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@custom_message_decorator("Starting the function...")
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

Decoratori pentru Metode în clase

Decoratorii pot fi folosiți și cu metode în cadrul claselor. Utilizările obișnuite includ apelurile metodelor de înregistrare, controlul accesului și rezultatele cache. Iată un exemplu de utilizare a unui decorator pentru a înregistra apelurile de metodă într-o clasă.

def log_method_call(method):
    def wrapper(self, *args, **kwargs):
        print(f"Calling {method.__name__} with arguments {args} and keyword arguments {kwargs}")
        return method(self, *args, **kwargs)
    return wrapper

class MyClass:
    @log_method_call
    def my_method(self, x, y):
        print(f"Result: {x + y}")

obj = MyClass()
obj.my_method(5, 7)

Înlănțuirea decoratorilor

Puteți aplica mai mulți decoratori la o singură funcție. Se aplică de la cel mai interior decorator până la cel mai exterior. Acest lucru vă permite să compuneți diferite funcționalități împreună. Iată un exemplu de înlănțuire a doi decoratori:

def uppercase_decorator(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result.upper()
    return wrapper

def exclamation_decorator(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result + "!"
    return wrapper

@exclamation_decorator
@uppercase_decorator
def greet(name):
    return f"Hello, {name}"

print(greet("Alice"))

Concluzie

Decoratorii sunt un instrument versatil în Python care vă permite să îmbunătățiți sau să modificați comportamentul funcțiilor și metodelor. Folosind decoratori, puteți adăuga funcționalități reutilizabile în baza de cod fără a schimba logica de bază a funcțiilor dumneavoastră. Fie pentru înregistrare, sincronizare sau modificarea rezultatelor, decoratorii vă ajută să vă păstrați codul curat și ușor de întreținut. Exersați folosirea decoratorilor pentru a deveni mai pricepuți și pentru a le valorifica puterea în proiectele dvs. Python.