Çfarë janë dekoratorët dhe si shkruani një?

Question

Accepted Answer

Një **dekorator** është një funksion që **mbështjellin një funksion tjetër** për të shtuar sjellje pa ndryshuar kodin origjinal. Zbatohet me sintaksën `@decorator` mbi një funksion — një mënyrë e pastër për të shtuar shqetësime tërthore (cross-cutting concerns) si regjistrim, timing, cache ose kontroll i qasjes.

## Si funksionojnë dekoratorët

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

Sintaksa `@my_decorator` është sheqer për `greet = my_decorator(greet)` — zëvendëson `greet` me `wrapper`, i cili ekzekuton kod shtesë rreth thirrjes origjinale. `*args, **kwargs` e bën mbështjellin të funksionojë për çdo nënshkrim funksioni.

## Një shembull praktik: 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)` është i rëndësishëm — pa të, funksioni i mbështjellur humb emrin origjinal dhe docstring-un.

## Dekoratorët me argumente

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

Një dekorator me parametra ka nevojë për një shtresë shtesë (një funksion që kthehet një dekorator).

## Dekoratorët e zakonshëm të integruar / të bibliotekës

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

## Pse ka rëndësi

Dekoratorët janë një veçori e fuqishme, karakteristike e Python për **shtimin e sjelljeve të rimatshme** (regjistrim, timing, cache, autentifikim, validim, rutim) në funksione në një mënyrë të pastër dhe deklarative — duke ndarë shqetësimet tërthore nga logjika bërthamë.

Janë kudo në Python-in real: frameworks e internetit (`@app.route`), cache (`@lru_cache`), klasa (`@property`) dhe testim.

Kuptuesa e mënyrës se si t'i shkruajmë ato (një funksion mbështjellëse, `*args/**kwargs`, `functools.wraps`) dhe forma me parametra ju lejon të përdorni saktë dekoratorët e ekosistemit dhe të ndërtoni përshkrimimet tuaja të rimatshme.