Functional Programming

What you'll learn

In Python, functions are first-class objects — you can store them, pass them, and return them like any value. That unlocks a powerful, expressive style: functional programming. It's the foundation for decorators (next module) and for clean data transformations.

By the end you'll be able to:

• Treat functions as first-class objects
• Write higher-order functions
• Use map, filter, and reduce
• Understand closures and reach for functools

Functions as objects

A function is a value. You can assign it to a variable, put it in a list or dict, and pass it around — without calling it (no parentheses). This is the idea everything else in this module builds on:

def shout(text):
    return text.upper() + "!"

greet = shout                # assign a function to a variable
print(greet("hi"))

funcs = [str.upper, str.lower, str.title]   # functions in a list
for f in funcs:
    print(f("Hello World"))

Higher-order functions

A higher-order function takes a function as an argument, returns one, or both. This lets you parameterize behavior, not just data — the caller decides what happens:

def apply_twice(func, value):     # takes a function as an argument
    return func(func(value))

def add_three(x):
    return x + 3

print(apply_twice(add_three, 10))     # 10 -> 13 -> 16
print(apply_twice(lambda s: s + "!", "hi"))

map, filter & reduce

The classic functional trio transforms sequences. map applies a function to every item, filter keeps items matching a predicate, and reduce (from functools) folds a sequence into a single value:

from functools import reduce

nums = [1, 2, 3, 4, 5, 6]

evens = list(filter(lambda n: n % 2 == 0, nums))
squared = list(map(lambda n: n * n, nums))
total = reduce(lambda acc, n: acc + n, nums, 0)

print(evens)
print(squared)
print(total)

# Often a comprehension is clearer than map/filter:
print([n * n for n in nums if n % 2 == 0])

Closures

When an inner function remembers variables from the enclosing function even after that function has returned, it's a closure. It "closes over" those values — a clean way to build specialized functions and the mechanism behind decorators:

def make_multiplier(factor):       # 'factor' is captured by the inner function
    def multiply(x):
        return x * factor          # closure remembers factor
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(10))      # 20
print(triple(10))      # 30

functools

The functools module is a treasure chest. partial pre-fills some arguments to make a specialized version of a function; lru_cache memoizes results so repeated calls are instant; and wraps (next module) preserves metadata on wrapped functions:

from functools import partial, lru_cache

# partial: pre-fill some arguments
def power(base, exp):
    return base ** exp
square = partial(power, exp=2)
print(square(5))       # 25

# lru_cache: memoize expensive calls automatically
@lru_cache
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)
print(fib(30))         # fast, thanks to caching

Recap & quick check

Closures and higher-order functions lead directly to one of Python's most beloved features. Next up: Module 24 — Decorators.