ਡੈਕੋਰੇਟਰ ਕੀ ਹਨ ਅਤੇ ਤੁਸੀਂ ਇੱਕ ਕਿਵੇਂ ਲਿਖਦੇ ਹੋ?

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` ਵਰੈਪਰ ਨੂੰ ਕਿਸੇ ਵੀ ਫ਼ੰਕਸ਼ਨ ਸਿਗਨੇਚਰ ਲਈ ਕੰਮ ਕਰਦਾ ਬਣਾਉਂਦਾ ਹੈ।

## ਇੱਕ ਵਿਹਾਰਕ ਉਦਾਹਰਣ: ਸਮਾਂ

```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 ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ — ਕ੍ਰਾਸ-ਕਟਿੰਗ ਦੁਆਵਾਂ ਨੂੰ ਮੂਲ ਤਰਕ ਤੋਂ ਵੱਖ ਕਰਦੇ ਹਨ।

ਇਹ ਅਸਲ Python ਵਿੱਚ ਸਭ ਥਾਵਾਂ ਹਨ: ਵੀ framework (`@app.route`), ਕੈਸ਼ਿੰਗ (`@lru_cache`), ਕਲਾਸਾਂ (`@property`), ਅਤੇ ਟੈਸਟਿੰਗ।

ਇਹ ਸਮਝਣਾ ਕਿ ਇਨ੍ਹਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ (ਇੱਕ ਵਰੈਪਰ ਫ਼ੰਕਸ਼ਨ, `*args/**kwargs`, `functools.wraps`) ਅਤੇ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਰੂਪ ਤੁਹਾਨੂੰ ਈਕੋਸਿਸਟਮ ਦੇ ਡੈਕੋਰੇਟਰ ਨੂੰ ਸਹੀ ਤਰਾਂ ਵਰਤਣ ਅਤੇ ਆਪਣੀਆਂ ਦੁਬਾਰਾ ਵਰਤੋਂ ਯੋਗ ਅਬਸ਼ਾਸ ਬਣਾਉਣ ਦੋਵਾਂ ਦੀ ਇਜ਼ਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।