Advanced Functions: Lambdas, Closures & Decorators

Master Python’s advanced function features — first-class objects, lambdas, *args/**kwargs, closures, and custom decorator patterns.

Python’s multi-paradigm nature lets you treat functions as first-class citizens: you can store them in variables, pass them into other functions, return them as values, and inspect their attributes. This goes far beyond simple code reuse — it unlocks powerful patterns like closures (functions that remember their creation environment) and decorators (wrappers that extend behaviour without touching the original code). This page covers every advanced function concept you need before diving into FastAPI and modern Python libraries.

Functions as First-Class Objects

In Python, a function is an object in memory with a type, an identity, and a value. You can manipulate it like any other value:

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

# 1. Assign to another variable
say_hello = greet
print(say_hello("Aarav"))   # Hello, Aarav!

# 2. Store in a list
def shout(name):
    return f"HELLO, {name}!"

actions = [greet, shout]
for action in actions:
    print(action("Amit"))
# Hello, Amit!
# HELLO, Amit!

# 3. Pass as an argument
def run_action(name, action_func):
    return action_func(name)

print(run_action("Dev", greet))   # Hello, Dev!

# 4. Inspect built-in attributes
print(greet.__name__)   # greet
print(id(greet))        # memory address

Lambda Functions

A lambda is a small, anonymous function defined with a single expression. No return keyword is needed — the expression is evaluated and returned automatically.

# Standard function
def add(x, y):
    return x + y

# Lambda equivalent
add_lambda = lambda x, y: x + y
print(add_lambda(3, 7))   # 10

Real-World Lambda Example

prices = [100, 250, 500]
prices_with_gst = list(map(lambda price: price * 1.18, prices))
print(prices_with_gst)   # [118.0, 295.0, 590.0]

Multi-line Lambda Expressions (Nested Conditionals)

You can wrap a single expression across multiple lines using parentheses:

classify_score = lambda score: (
    "Excellent" if score >= 90 else
    "Good"      if score >= 75 else
    "Pass"      if score >= 50 else
    "Fail"
)

print(classify_score(82))   # Good
print(classify_score(45))   # Fail

Complex nested conditionals inside a lambda hurt readability. If your logic spans multiple lines or requires multiple statements (assignments, loops, print calls), use a normal def function.

Lambdas shine as concise inline arguments to higher-order functions:

points = [(1, 2), (3, 1), (5, 0)]
sorted_points = sorted(points, key=lambda p: p[1])
print(sorted_points)   # [(5, 0), (3, 1), (1, 2)]

Variable-Length Arguments (*args and **kwargs)

Accept an arbitrary number of arguments using starred parameters:

def print_everything(*args, **kwargs):
    print("Positional args:", args)
    print("Keyword args:  ", kwargs)

print_everything(1, 2, 3, name="Alice", age=25)
# Positional args: (1, 2, 3)
# Keyword args:   {'name': 'Alice', 'age': 25}

• *args collects extra positional arguments into a tuple.
• **kwargs collects extra keyword arguments into a dictionary.

Closures

A closure is a nested function that retains access to variables from its enclosing function’s scope — even after the outer function has finished executing.

Three conditions must hold:

1. There is a nested (inner) function.
2. The inner function references a variable from the outer scope.
3. The outer function returns the inner function.

def make_multiplier(factor):
    def multiplier(number):
        return number * factor   # 'factor' is captured from outer scope
    return multiplier

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

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

Each call to make_multiplier() creates an independent closure with its own factor value — double and triple are completely separate functions.

Decorators

A decorator is a higher-order function that wraps another function to add behaviour before, after, or around the original call — without modifying its source code.

Writing a Basic Decorator

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.

The @my_decorator syntax is shorthand for say_hello = my_decorator(say_hello).

Decorating Functions with Arguments

Use *args and **kwargs in the wrapper so the decorator works with any function signature:

def log_arguments(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_arguments
def add_numbers(a, b):
    return a + b

add_numbers(10, 20)
# Calling add_numbers with args=(10, 20), kwargs={}
# add_numbers returned: 30

Practical Decorator Example — Timing

import time

def timer(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

@timer
def slow_operation():
    time.sleep(0.1)
    return "done"

print(slow_operation())
# slow_operation took 0.1002s
# done

For production decorators, wrap the inner function with functools.wraps(func) to preserve the original function’s __name__, __doc__, and other metadata:

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper