Mik azok a dekorátorok, és hogyan írunk egyet?

Question

Accepted Answer

A **dekorátor** egy olyan függvény, amely **egy másik függvényt burkoláz** viselkedés hozzáadása céljából, az eredeti kód módosítása nélkül. A függvény feletti `@decorator` szintaxis használatával alkalmazzuk — egy tiszta módszer kereszt-vágó problémák (naplózás, időzítés, gyorsítótárazás, hozzáférés-vezérlés) hozzáadására.

## Hogyan működnek a dekorátorok

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

A `@my_decorator` szintaxis szintaxis cukor a `greet = my_decorator(greet)` számára — helyettesíti a `greet` -et a `wrapper` -rel, amely az eredeti hívás körül extra kódot futtat. Az `*args, **kwargs` lehetővé teszi, hogy a wrapper bármilyen függvényi aláíráshoz működjön.

## Gyakorlati példa: időzítés

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

A `@functools.wraps(func)` fontos — nélküle a burkolózott függvény elveszíti eredeti nevét és docstring -jét.

## Paraméterekkel rendelkező dekorátorok

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

Egy paraméterezett dekorátor további szinttet igényel (egy függvény, amely dekorátort ad vissza).

## Gyakori beépített / könyvtári dekorátorok

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

## Miért fontos

A dekorátorok erőteljes, jellegzetesen Pythonos megoldás az **újrafelhasználható viselkedés hozzáadásához** (naplózás, időzítés, gyorsítótárazás, hitelesítés, validálás, útválasztás) függvényekhez tisztán és deklaratív módon — a kereszt-vágó problémák szétválasztásával az alapvető logikától.

Mindenütt jelen vannak az igazi Python-ban: web framework-ökben (`@app.route`), gyorsítótárazásban (`@lru_cache`), osztályokban (`@property`) és tesztelésben.

Az írásuk módjának megértése (burkoló függvény, `*args/**kwargs`, `functools.wraps`) és a paraméterezett forma lehetővé teszi, hogy helyesen használd az ökoszisztéma dekorátorait, és saját újrafelhasználható absztrakciókat buildj.