Advanced Python Functions: Closures and Decorators

Python treats functions as first-class objects, which means you can assign them to variables, pass them as arguments, return them from other functions, and store them in data structures. This single fact unlocks closures, decorators, and an enormous amount of elegant, reusable code. This page takes you from that foundation all the way through writing production-quality decorators.

Functions as First-Class Objects

def greet(name: str) -> str:
    return f"Hello, {name}!"

def shout(name: str) -> str:
    return f"HELLO, {name.upper()}!"

# 1. Assign a function to another variable
say_hi = greet
print(say_hi("Priya"))      # Hello, Priya!

# 2. Store functions in a list
formatters = [greet, shout]
for fn in formatters:
    print(fn("Dev"))        # Hello, Dev! then HELLO, DEV!

# 3. Pass a function as an argument (higher-order function)
def run(name: str, formatter):
    return formatter(name)

print(run("Arjun", greet))  # Hello, Arjun!
print(run("Arjun", shout))  # HELLO, ARJUN!

# 4. Inspect function metadata
print(greet.__name__)       # greet
print(type(greet))          # <class 'function'>

Variable-Length Arguments

When you don’t know in advance how many arguments a function will receive, use *args for positional arguments and **kwargs for keyword arguments.

def summarise(*args, **kwargs):
    print("Positional:", args)    # tuple
    print("Keyword:   ", kwargs)  # dict

summarise(1, 2, 3, name="Alice", role="admin")
# Positional: (1, 2, 3)
# Keyword:    {'name': 'Alice', 'role': 'admin'}

# Practical use: flexible price calculator
def calculate_total(*prices: float, tax_rate: float = 0.1) -> float:
    subtotal = sum(prices)
    return subtotal * (1 + tax_rate)

print(calculate_total(100, 250, 50, tax_rate=0.18))  # 472.0

Closures

A closure is an inner function that remembers variables from its enclosing scope even after the outer function has finished executing. Three conditions create a closure:

There is a nested function.
The nested function references a variable from the enclosing function.
The enclosing function returns the nested function.

def make_multiplier(factor: int):
    def multiply(number: int) -> int:
        return number * factor   # 'factor' is captured from outer scope
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(10))  # 20
print(triple(10))  # 30

# Inspect what a closure has captured
print(double.__closure__[0].cell_contents)  # 2

Closures are powerful because each call to make_multiplier creates an independent function that permanently carries its own factor.

Real-world closure: a configurable validator

def make_range_validator(minimum: float, maximum: float):
    def validate(value: float) -> bool:
        return minimum <= value <= maximum
    return validate

is_valid_age    = make_range_validator(0, 120)
is_valid_rating = make_range_validator(1.0, 5.0)

print(is_valid_age(25))       # True
print(is_valid_age(200))      # False
print(is_valid_rating(4.5))   # True

Decorators

A decorator wraps a function to extend its behaviour without changing its source code. Under the hood it is a higher-order function: it receives the original function, defines a wrapper that adds behaviour around it, and returns the wrapper.

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"→ Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"← {func.__name__} finished")
        return result
    return wrapper

@my_decorator
def add(a: int, b: int) -> int:
    return a + b

print(add(3, 7))
# → Calling add
# ← add finished
# 10

The @my_decorator syntax is just shorthand for add = my_decorator(add).

Preserving function metadata with `functools.wraps`

Without functools.wraps, the wrapper replaces the original function’s name and docstring. Always use @wraps when writing decorators.

import functools

def log_calls(func):
    @functools.wraps(func)          # preserves __name__, __doc__, etc.
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with {args}, {kwargs}")
        result = func(*args, **kwargs)
        print(f"Returned: {result}")
        return result
    return wrapper

@log_calls
def multiply(x: float, y: float) -> float:
    """Multiply two numbers."""
    return x * y

multiply(4, 5)
print(multiply.__name__)  # multiply  (not 'wrapper'!)
print(multiply.__doc__)   # Multiply two numbers.

Decorator with arguments

To pass arguments to a decorator, add an extra layer of nesting — a function that returns the decorator:

import functools
import time

def retry(max_attempts: int = 3, delay: float = 1.0):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"Attempt {attempt} failed: {e}")
                    if attempt < max_attempts:
                        time.sleep(delay)
            raise RuntimeError(f"{func.__name__} failed after {max_attempts} attempts")
        return wrapper
    return decorator

@retry(max_attempts=3, delay=0.5)
def fetch_data(url: str) -> dict:
    # Simulated flaky network call
    raise ConnectionError("timeout")

# fetch_data("https://api.example.com/data")

Built-in Decorators

Python ships with three decorator-like tools that you will use frequently on class methods:

@staticmethod — no self or cls

A static method belongs to the class’s namespace but receives no automatic first argument. Use it for utility functions logically grouped with the class but not dependent on instance or class state.

class MathUtils:
    @staticmethod
    def add(a: float, b: float) -> float:
        return a + b

print(MathUtils.add(3, 4))   # 7 — called on the class directly

@classmethod — receives cls

A class method receives the class itself as its first argument (cls). Use it to define alternative constructors.

from dataclasses import dataclass

@dataclass
class Temperature:
    celsius: float

    @classmethod
    def from_fahrenheit(cls, f: float) -> "Temperature":
        return cls((f - 32) * 5 / 9)

t = Temperature.from_fahrenheit(98.6)
print(round(t.celsius, 1))   # 37.0

@property — computed attributes

A property lets you define a method that is accessed like an attribute. Pair it with @name.setter to add validation on assignment.

class Circle:
    def __init__(self, radius: float):
        self._radius = radius

    @property
    def radius(self) -> float:
        return self._radius

    @radius.setter
    def radius(self, value: float):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

    @property
    def area(self) -> float:
        import math
        return math.pi * self._radius ** 2

c = Circle(5)
print(round(c.area, 2))   # 78.54
c.radius = 10
print(round(c.area, 2))   # 314.16

Practical Decorator Examples

Timing
Simple Cache
Access Control

import functools
import time

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

@timer
def slow_sum(n: int) -> int:
    return sum(range(n))

slow_sum(10_000_000)   # slow_sum took 0.3142s

import functools

def simple_cache(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@simple_cache
def fibonacci(n: int) -> int:
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(40))  # fast — results are cached

Python’s standard library already includes functools.lru_cache and functools.cache that do this with more options. Prefer those in production code.

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

import functools

def require_role(role: str):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(user: dict, *args, **kwargs):
            if user.get("role") != role:
                raise PermissionError(
                    f"{func.__name__} requires role '{role}'"
                )
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

@require_role("admin")
def delete_user(user: dict, target_id: int):
    print(f"Deleted user {target_id}")

admin = {"name": "Alice", "role": "admin"}
guest = {"name": "Bob",   "role": "guest"}

delete_user(admin, 42)         # Deleted user 42
# delete_user(guest, 42)       # PermissionError

Core Python

Advanced Python

Pydantic

Advanced Python Functions: Closures and Decorators

Functions as First-Class Objects

Variable-Length Arguments

Closures

Real-world closure: a configurable validator

Decorators

Preserving function metadata with `functools.wraps`

Decorator with arguments

Built-in Decorators

Practical Decorator Examples

​Functions as First-Class Objects

​Variable-Length Arguments

​Closures

​Real-world closure: a configurable validator

​Decorators

​Preserving function metadata with functools.wraps

​Decorator with arguments

​Built-in Decorators

​Practical Decorator Examples

Functions as First-Class Objects

Variable-Length Arguments

Closures

Real-world closure: a configurable validator

Decorators

Preserving function metadata with `functools.wraps`

Decorator with arguments

Built-in Decorators

Practical Decorator Examples