ડેકોરેટર્સ શું છે અને તમે કોને કેવી રીતે લખો છો?

Question

Accepted Answer

**ડેકોરેટર** એક ફંક્શન છે જે **બીજા ફંક્શનને આવરણ આપે છે** વર્તન ઉમેરવા માટે, મૂળના કોડને સંશોધન કર્યા વિના. તે ફંક્શનની ઉપર `@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)` મહત્વપૂર્ણ છે — તેના વિના, આવૃત્ત ફંક્શન તેનું મૂળ નામ અને docstring ગુમાવે છે.

## દલીલો સાથે ડેકોરેટર્સ

```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`) અને પેરામીટર કરેલ ફોર્મ તમને ઇકોસિસ્ટમના ડેકોરેટર્સ યોગ્ય રીતે ઉપયોગ કરવા અને તમારા પોતાના પુનઃ-વપરાશી સાર્વત્રિક બનાવવા દેય છે.