डेकोरेटर्स म्हणजे काय आणि तुम्ही एक कसे लिहिता?

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`) आणि पैरामीटराइज्ड फॉर्म हे तुम्हाला इकोसिस्टमचे डेकोरेटर्स योग्यरित्या वापरण्यास आणि तुमचे स्वतःचे पुनः वापरण्यायोग्य अमूर्तताएं तयार करण्यास सक्षम करते.