డెకరేటర్లు ఏమిటి మరియు మీరు ఒకటి ఎలా వ్రాస్తారు?

Question

Accepted Answer

A **decorator** అనేది మరొక ఫంక్షన్‌ను **చుట్టుముట్టే** ఒక ఫంక్షన్, ఇది అసలు కోడ్‌ను సవరించకుండా ప్రవర్తన జోడించటానికి. ఇది ఫంక్షన్ పైన `@decorator` సింటాక్స్‌తో వర్తించబడుతుంది — లాగింగ్, టైమింగ్, క్యాచింగ్ లేదా యాక్సెస్ కంట్రోల్‌ వంటి క్రాస్-కటింగ్ సంబంధాలను జోడించడానికి ఒక స్వచ్ఛ మార్గం.

## డెకరేటర్లు ఎలా పనిచేస్తాయి

```python
def my_decorator(func):
    def wrapper(*args, **kwargs):       # wraps the original function
        print("before")
        result = func(*args, **kwargs)  # call the original
        print("after")
        return result
    return wrapper                       # return the wrapped version

@my_decorator
def greet(name):
    print(f"Hello {name}")

greet("Ann")
# Output: before / Hello Ann / after
```

`@my_decorator` సింటాక్స్ `greet = my_decorator(greet)` కోసం చక్కెర — ఇది `greet` ను `wrapper` తో భర్తీ చేస్తుంది, ఇది అసల కాల చుట్టూ అదనపు కోడ్‌ను అమలు చేస్తుంది. `*args, **kwargs` wrapper ని ఏదైనా ఫంక్షన్ సంతకానికి పనిచేయడానికి చేస్తుంది.

## ఒక ఆచరణాత్మక ఉదాహరణ: టైమింగ్

```python
import time, functools

def timed(func):
    @functools.wraps(func)        # preserves func's name/docstring (important!)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter() - start:.3f}s")
        return result
    return wrapper

@timed
def slow_task():
    time.sleep(1)
```

`@functools.wraps(func)` ముఖ్యమైనది — ఇది లేకుండా, చుట్టుముట్టిన ఫంక్షన్ దాని అసలు పేరు మరియు డాక్‌స్ట్రింగ్‌ను కోల్పోతుంది.

## వాదనలతో డెకరేటర్లు

```python
def repeat(times):               # outer takes the decorator's argument
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(times=3)
def hello(): print("hi")  # prints "hi" three times
```

పారామీటర్‌సంపన్న డెకరేటర్‌కు అదనపు పొర అవసరం (ఒక డెకరేటర్‌ను అందించే ఫంక్షన్).

## సాధారణ నిర్మిత / లైబ్రరీ డెకరేటర్లు

```text
@property            → turn a method into a computed attribute
@staticmethod / @classmethod → method types
@functools.lru_cache → memoize results
@app.route("/")      → web framework routing (Flask)
@pytest.fixture      → test fixtures
```

## ఇది ఎందుకు ముఖ్యమైనది

డెకరేటర్లు **పునర్ముపయోగ చేయగల ప్రవర్తనను జోడించటానికి** ఒక శక్తిశాలీ, విభిన్ন-పైథాన్ ఫీచర్ (లాగింగ్, టైమింగ్, క్యాచింగ్, ప్రామాణీకరణ, ధృవీకరణ, రూటింగ్) ఫంక్షన్‌లకు స్వచ్ఛంగా మరియు ప్రకటనాత్మకంగా — క్రాస్-కటింగ్ సంబంధాలను కోర్ లాజిక్ నుండి వేరు చేయడం.

వాస్తవ Python: వెబ్ ఫ్రేమ్‌వర్క్‌లలో అవి ఎక్కడైనా ఉన్నాయి (`@app.route`), క్యాచింగ్ (`@lru_cache`), తరగతులు (`@property`), మరియు పరీక్ష.

వాటిని ఎలా రాయాలో అర్థం చేసుకోవడం (wrapper ఫంక్షన్, `*args/**kwargs`, `functools.wraps`) మరియు పారామీటర్‌సంపన్న రూపం ఈకోసిస్టమ్ యొక్క డెకరేటర్‌లను సరిగ్గా ఉపయోగించటానికి మరియు మీ స్వంత పునర్ముపయోగ చేయగల నైరూప్యతలను నిర్మించటానికి మిమ్మల్ని సక్షమ చేస్తుంది.