डेकोरेटर्स क्या हैं और आप एक कैसे लिखते हैं?

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
```

## यह महत्वपूर्ण क्यों है

डेकोरेटर्स **पुन: प्रयोज्य व्यवहार जोड़ने** के लिए एक शक्तिशाली, विशिष्ट-Pythonic सुविधा है (लॉगिंग, समय निर्धारण, कैशिंग, प्रमाणीकरण, सत्यापन, रूटिंग) फ़ंक्शन्स को स्वच्छ और घोषणात्मक रूप से — क्रॉस-कटिंग चिंताओं को मूल तर्क से अलग करके।

वे असली Python में हर जगह हैं: वेब फ्रेमवर्क (`@app.route`), कैशिंग (`@lru_cache`), क्लासेस (`@property`), और परीक्षण।

यह समझना कि उन्हें कैसे लिखें (एक wrapper फ़ंक्शन, `*args/**kwargs`, `functools.wraps`) और पैरामीटरयुक्त फॉर्म आपको इकोसिस्टम के डेकोरेटर्स का सही तरीके से उपयोग करने और अपनी खुद की पुन: प्रयोज्य सार्वभौमिकताएं बनाने देता है।