Hva er dekoratører og hvordan skriver du en?

Question

IT Interview Practice · Accepted Answer

En **dekoratør** er en funksjon som **omslutter en annen funksjon** for å legge til atferd uten å endre originalens kode. Den brukes med `@decorator`-syntaksen over en funksjon — en ren måte å legge til tversgående bekymringer som logging, timing, caching eller tilgangskontroll.

## Hvordan dekoratører fungerer

```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`-syntaksen er sukker for `greet = my_decorator(greet)` — den erstatter `greet` med `wrapper`, som kjører ekstra kode rundt originalanropet. `*args, **kwargs` gjør at wrapperen fungerer for enhver funksjonssignatur.

## Et praktisk eksempel: 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)` er viktig — uten det mister den omsluttede funksjonen sitt originale navn og docstring.

## Dekoratører med argumenter

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

En parameterisert dekoratør trenger et ekstra lag (en funksjon som returnerer en dekoratør).

## Vanlige innebygde / bibliotekdekoratører

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

## Hvorfor det er viktig

Dekoratører er en kraftig, særegen Python-funksjon for **å legge til gjenbrukbar atferd** (logging, timing, caching, autentisering, validering, ruting) til funksjoner rent og deklarativt — og separerer tversgående bekymringer fra kjernekjørelogikk.

De finnes overalt i ekte Python: nett-rammeverk (`@app.route`), caching (`@lru_cache`), klasser (`@property`) og testing.

Å forstå hvordan man skriver dem (en wrapperfunksjon, `*args/**kwargs`, `functools.wraps`) og den parameteriserte formen lar deg både bruke økosystemets dekoratører riktig og bygge dine egne gjenbrukbare abstraksjoner.

Hvordan dekoratører fungerer

Et praktisk eksempel: timing

Dekoratører med argumenter

Vanlige innebygde / bibliotekdekoratører

Hvorfor det er viktig

Relaterte spørsmål