డెకరేటర్లు: ఫంక్షన్లను సవరించే విధులు

ఒక డెకరేటర్ అనేది మరొక ఫంక్షన్‌ని తీసుకొని aని తిరిగి ఇచ్చే ఒక ఫంక్షన్ దాని "అలంకరించిన" వెర్షన్. ప్రవర్తనను జోడించడానికి ఇది ఒక శక్తివంతమైన మార్గం శరీరాన్ని తాకకుండా (లాగింగ్, టైమింగ్, కాషింగ్, మళ్లీ ప్రయత్నించడం, ధ్రువీకరణ). అసలు విధి.

విలువలుగా విధులు

పైథాన్‌లో, విధులు వస్తువులు: మీరు వాటిని పాస్ చేయవచ్చు, వాటిని తిరిగి ఇవ్వవచ్చు, వాటిని కేటాయించవచ్చు.

def saluta():
    print("ciao")

f = saluta   # NIENTE parentesi: assegno la funzione
f()          # 'ciao'

కనీస డెకరేటర్

def log(func):
    def wrapper(*args, **kwargs):
        print(f"chiamo {func.__name__}")
        risultato = func(*args, **kwargs)
        print(f"ho finito {func.__name__}")
        return risultato
    return wrapper

def somma(a, b):
    return a + b

somma = log(somma)   # ora somma è "wrapper"
somma(2, 3)
# chiamo somma
# ho finito somma
# 5

@decorator సింటాక్స్

somma = log(somma) అసైన్‌మెంట్ @తో మరింత సొగసైనదిగా వ్రాయబడింది:

@log
def somma(a, b):
    return a + b

ఇది సరిగ్గా అదే విషయం. నిర్వచనం పైన @log దీనికి సమానం: "ఈ ఫంక్షన్ నిర్వచించబడిన వెంటనే, దానిని log(function)తో భర్తీ చేయండి".

*args, **kwargs: ఏదైనా సంతకాన్ని ఆమోదించండి

def wrapper(*args, **kwargs):
    return func(*args, **kwargs)

*args స్థాన ఆర్గ్యుమెంట్‌లను, **kwargs కీవర్డ్ ఆర్గ్యుమెంట్‌లను సేకరిస్తుంది. వారు అనుమతించారు మీరు ఏదైనా ఫంక్షన్‌తో పని చేసే రేపర్‌లను వ్రాస్తారు.

functools.wraps: మెటాడేటాను భద్రపరచండి

wraps లేకుండా, అలంకరించబడిన ఫంక్షన్ __name__, __doc__, సూచనలు:

from functools import wraps

def log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        ...
        return func(*args, **kwargs)
    return wrapper

ఉదాహరణ: @timeit

from functools import wraps
import time

def timeit(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        t0 = time.perf_counter()
        risultato = func(*args, **kwargs)
        dt = time.perf_counter() - t0
        print(f"{func.__name__} ha impiegato {dt*1000:.2f} ms")
        return risultato
    return wrapper

@timeit
def somma_grande():
    return sum(range(10**6))

somma_grande()

stdlib నుండి డెకరేటర్లు

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2: return n
    return fib(n - 1) + fib(n - 2)

fib(100)  # istantaneo grazie alla cache

• @lru_cache — స్వచ్ఛమైన ఫంక్షన్ ఫలితాలను జ్ఞాపకం చేస్తుంది.
• @property — ఒక పద్ధతిని లక్షణంగా బహిర్గతం చేస్తుంది (OOP మాడ్యూల్‌లో కనిపిస్తుంది).
• @staticmethod, @classmethod — self ఎలా ఆమోదించబడుతుందో మార్చండి.

వాదనలతో అలంకారకులు

డెకరేటర్లు కూడా వాదనలను అంగీకరించవచ్చు. దీన్ని అమలు చేయడానికి, మీరు తప్పనిసరిగా మూడు స్థాయిల సమూహ ఫంక్షన్‌లను వ్రాయాలి: బయటి ఫంక్షన్ డెకరేటర్ ఆర్గ్యుమెంట్‌లను అందుకుంటుంది, మధ్య ఫంక్షన్ అలంకరించబడిన ఫంక్షన్‌ను అందుకుంటుంది మరియు లోపలి ఫంక్షన్ (wrapper) కాల్‌ల సమయంలో అలంకరించబడిన ఫంక్షన్‌కు పంపబడిన వాస్తవ ఆర్గ్యుమెంట్‌లను అందుకుంటుంది.

మీరే ప్రయత్నించండి

వ్యాయామం సమీక్షించండి

అదనపు సవాలు