Crearea și înlănțuirea decoratorilor de funcție în Python

Îmbunătățirea funcțiilor Python cu decoratori

În Python, decoratorii sunt un instrument puternic pentru modificarea comportamentului funcțiilor sau metodelor. Acestea permit dezvoltatorilor să înglobeze funcționalități suplimentare în jurul unei funcții existente într-un mod curat și lizibil. Înțelegând cum să creați și să înlănțuiți decoratorii, puteți îmbunătăți foarte mult modularitatea și lizibilitatea codului dvs.

Acest articol vă va ghida prin procesul de realizare a doi decoratori specifici: unul pentru a face textul aldine și altul pentru a face textul italic. De asemenea, vom demonstra cum să înlănțuim acești decoratori pentru a obține rezultatul dorit. Până la sfârșitul acestui tutorial, veți putea să apelați o funcție simplă și să primiți un șir formatat cu etichete HTML atât aldine, cât și italice.

Înțelegerea decoratorilor cu funcții Python

Scripturile furnizate demonstrează cum să creați și să înlănțuiți decoratorii de funcții în Python pentru a modifica comportamentul funcțiilor. Un decorator în Python este definit folosind def cuvânt cheie pentru a crea o funcție care ia o altă funcție ca argument și returnează o funcție nouă. The make_bold decorator împachetează rezultatul funcției pe care o decorează cu etichete HTML aldine folosind formatarea f-string: f"<b>{func()}</b>". În mod similar, cel make_italic decoratorul înfășoară rezultatul în etichete italice: f"<i>{func()}</i>". Când acești decoratori sunt aplicați la o funcție folosind @decorator_name sintaxa, ele modifică ieșirea funcției prin adăugarea etichetelor HTML respective.

Al doilea script introduce o abordare mai versatilă prin crearea unei funcții de ordin superior, add_html_tag, care generează decoratori pentru orice etichetă HTML specificată. Această funcție ia o etichetă HTML ca argument și returnează un decorator care include rezultatul funcției în eticheta specificată: f"<{tag}>{func()}</{tag}>". Prin utilizarea @add_html_tag("b") și @add_html_tag("i"), putem înlănțui acești decoratori pentru a încheia rezultatul say_hello funcţionează atât în ​​etichete aldine, cât şi în cursive, rezultând „Buna ziua„. Aceste exemple ilustrează puterea și flexibilitatea decoratorilor Python în îmbunătățirea și personalizarea comportamentului funcției într-un mod curat și reutilizabil.

def make_bold(func):
    def wrapper():
        return f"<b>{func()}</b>"
    return wrapper

def make_italic(func):
    def wrapper():
        return f"<i>{func()}</i>"
    return wrapper

@make_bold
@make_italic
def say():
    return "Hello"

print(say())

def add_html_tag(tag):
    def decorator(func):
        def wrapper():
            return f"<{tag}>{func()}</{tag}>"
        return wrapper
    return decorator

@add_html_tag("b")
@add_html_tag("i")
def say_hello():
    return "Hello"

print(say_hello())

Tehnici avansate de decorare Python

Dincolo de simpla modificare a funcției, decoratorii Python oferă o modalitate puternică de a îmbunătăți reutilizarea și mentenabilitatea codului. Un caz de utilizare avansat este decoratorii parametrizați, care permit decoratorilor să accepte argumente. Această tehnică a fost ilustrată cu add_html_tag decorator în exemplele anterioare. Prin definirea unui decorator care generează alți decoratori, putem crea structuri de cod extrem de flexibile și reutilizabile. Decoratorii parametrizați ne permit să transmitem parametrii decoratorului însuși, permițând modificări dinamice și specifice contextului ale comportamentului funcției.

Un alt aspect important al decoratorilor este capacitatea lor de a menține metadatele funcției. Când o funcție este împachetată de un decorator, metadatele ei, cum ar fi numele și docstring, pot fi pierdute. Pentru a păstra aceste metadate, Python functools.wraps este folosit în cadrul decoratorului. Aplicand @functools.wraps în funcția wrapper, metadatele funcției originale sunt copiate, asigurându-se că instrumentele care se bazează pe aceste metadate, cum ar fi generatoarele de documentație, continuă să funcționeze corect. În plus, decoratorii pot fi stivuiți, așa cum se arată cu @make_bold și @make_italic exemple, pentru a aplica mai multe straturi de modificare a comportamentului într-un mod curat și lizibil.