डेकोरेटरहरू के हुन् र तपाई एकलाई कसरी लेख्नुहुन्छ?

Question

Accepted Answer

एक **डेकोरेटर** एक फ्याङ्क्शन हो जो **अर्को फ्याङ्क्शनलाई wrap** गरेर आचरण थप्छ, मूलको कोड परिवर्तन नगरी। यो फ्याङ्क्शनको माथिमा `@decorator` सिन्ट्याक्स लागु गरिन्छ — logging, timing, caching, वा access control जस्ता cross-cutting concerns थप्नको लागि एक सफा तरिका।

## डेकोरेटरहरू कसरी काम गर्छन्

```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 लाई कुनै पनि फ्याङ्क्शन signature को लागि काम गर्न सक्षम गर्छ।

## एक व्यावहारिक उदाहरण: timing

```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)` महत्त्वपूर्ण छ — यो बिना, wrap गरिएको फ्याङ्क्शनले यसको मूल नाम र 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
```

एक parameterized डेकोरेटरलाई एक अतिरिक्त तह चाहिन्छ (एक फ्याङ्क्शन जो डेकोरेटर फर्काउँछ)।

## सामान्य built-in / library डेकोरेटरहरू

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

## यो किन महत्त्वपूर्ण छ

डेकोरेटरहरू **पुनः प्रयोगयोग्य आचरण** (logging, timing, caching, authentication, validation, routing) फ्याङ्क्शनहरूमा सफाइ र घोषणात्मक ढङ्गले थप्नको लागि एक शक्तिशाली, विशेष रूपमा-Pythonic बिशेषता हुन् — cross-cutting concerns लाई core logic बाट अलग गर्दै।

तिनीहरू वास्तविक Python मा सर्वत्र छन्: web frameworks (`@app.route`), caching (`@lru_cache`), classes (`@property`), र testing।

तिनीहरू कसरी लेख्ने (एक wrapper फ्याङ्क्शन, `*args/**kwargs`, `functools.wraps`) र parameterized form बुझ्नु भएको कुरा तपाईलाई ecosystem को डेकोरेटरहरू सही तरिकाले प्रयोग गर्न र आफ्नो पुनः प्रयोगयोग्य अमूर्तताहरू निर्माण गर्न सक्षम गर्दछ।