Forge Learn/Functional Python & Iterators

Browsing as a guest. Sign in to save your progress and earn XP as you complete chapters.

Decorators

7 min read

You'll learn to

-Explain what a decorator is: a function that wraps another function
-Apply a decorator with `@decorator_name` syntax
-Build a simple timing or logging decorator from scratch

A decorator is a function that takes another function as input and returns a new function that wraps it, typically adding behavior before and/or after the original runs, without modifying the original function's own code. This directly builds on the closures chapter from the Functions module: a decorator is a closure whose remembered enclosing variable happens to be the function it is wrapping.

Building a Decorator by Hand

Before the @ syntax, look at what a decorator actually is: a function that accepts a function and returns a new function.

A logging "decorator", manually applied first

def log_calls(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

def add(a, b):
    return a + b

add = log_calls(add)   # manually wrap add with the decorator
add(3, 4)
# Calling add with args=(3, 4), kwargs={}
# add returned 7

Notice wrapper takes *args, **kwargs, exactly the accept-anything tool from the earlier functions module, so log_calls can wrap a function with any signature at all, not just ones that take two arguments.

The @decorator Syntax

@decorator_name placed directly above a function definition is exactly equivalent to the manual reassignment above: def add(...): ... followed by add = log_calls(add), just cleaner to read.

The same decorator, applied with @ syntax

def log_calls(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

@log_calls
def add(a, b):
    return a + b

add(3, 4)
# Calling add with args=(3, 4), kwargs={}
# add returned 7

A Timing Decorator

Another classic, genuinely useful decorator measures how long a function takes to run, using the time module.

A reusable timing decorator

import time

def timed(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timed
def slow_sum(n):
    return sum(range(n))

slow_sum(10_000_000)
# slow_sum took 0.1234s

Foreshadowing: Caching Is Just a Decorator

Here is the payoff for everything in this chapter and the closures chapter before it. What if, instead of timing a function, a wrapper checked whether it had already computed the result for these exact arguments, and returned the cached answer instead of recomputing it?

A tiny cache decorator: this is memoization

def cached(func):
    cache = {}  # remembered across calls, via closure, same trick as make_counter()
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@cached
def slow_square(n):
    print(f"Computing square of {n}...")
    return n * n

print(slow_square(5))  # Computing square of 5... \n 25
print(slow_square(5))  # 25, no "Computing..." printed, served from cache
print(slow_square(6))  # Computing square of 6... \n 36

This is exactly what memoization is: a cache, keyed by arguments, wrapped around a function that would otherwise repeat expensive work. The Algorithms phase of this course covers memoization for recursive algorithms in depth, and Python's own functools.lru_cache gives you this decorator for free, but the underlying mechanism is precisely the closure-plus-wrapper pattern you just built by hand.

-A decorator is a function that takes a function and returns a new (usually wrapping) function.
-@decorator_name above a def is sugar for func = decorator_name(func).
-A wrapper almost always accepts *args, **kwargs so it can wrap functions of any signature.
-A caching decorator is a closure holding a dict, checked and updated on every call. This is memoization, which the next phase of this course (Algorithms) builds on directly.

Interview Signal is part of Pro

See a real weak answer next to a real strong one for this exact topic.

Quiz is part of Pro

Test what you just read with a short quiz, and bank the XP.

Module Assignment is part of Pro

Write real, graded Python for this module - right here in the course.

map/filter/reduce & Functional Tools Type Hints & Static Typing

Discussion0

Join the Discussion

No comments yet. Be the first to start the thread!