சாজனங்கள் என்றால் என்ன மற்றும் ஒன்றை எவ்வாறு எழுதுவது?

Question

Accepted Answer

ஒரு **decorator** என்பது மற்றொரு செயல்பாட்டை **மடக்கும்** ஒரு செயல்பாடு ஆகும், நடத்தையைச் சேர்க்க, அசல் குறியீட்டை மாற்றாமல். இது ஒரு செயல்பாட்டுக்கு மேலே `@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 சம்பவம் ஆகும் (பதிவுசெய்தல், நேரம், கேஷ் செய்தல், அங்கீகாரம், சரிபார்ப்பு, வழிநடத்துதல்) செயல்பாடுகளுக்கு சுத்தமாக மற்றும் பிரகடனபூர்வகமாக — குறுக்குவெட்டு கவலைகளை மূல குறியீட்டிலிருந்து பிரிக்க.

அவை உண்மையான Python இல் எங்கும் உள்ளன: வலை கাঠামோ (`@app.route`), கேஷ் (`@lru_cache`), வகுப்புகள் (`@property`), மற்றும் சோதனை.

அவற்றை எவ்வாறு எழுதுவது என்பதைப் புரிந்துகொள்ளல் (wrapper செயல்பாடு, `*args/**kwargs`, `functools.wraps`) மற்றும் அளவுரு வடிவம் உங்களை இரண்டும் சாலை அமைப்பின் சாजனங்களை சரிதែக்க விட உங்கள் சொந்த மீண்டும் பயன்படுத்தக்கூடிய நடிப்பை உருவாக்க.