Academy — Sanjib Sikder

Functional Programming in Python

Python is not a purely functional language — it supports multiple styles. But it has strong functional programming tools, and knowing them makes certain classes of problems significantly cleaner.

The functional mindset treats functions as the primary unit of composition. Rather than building large, stateful procedures, you build small, pure functions and combine them. Python's functools module is the home of the most important tools for doing this well.

`partial` — Pre-filling Arguments

functools.partial creates a new function from an existing one with some arguments already filled in.

Python

Ctrl+Enter to run

from functools import partial

def power(base, exponent):
return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))
print(cube(3))
print(square(12))

partial(power, exponent=2) returns a new function — identical to power but with exponent permanently set to 2. You can call square with just the base. cube with just the base.

This is called partial application — specialising a general function into a more specific one. You write the general logic once, then derive specific versions from it.

Python

Ctrl+Enter to run

from functools import partial

def send_message(template, sender, recipient):
    return template.format(sender=sender, recipient=recipient)

welcome_template = #22c55e">"Dear {recipient}, welcome to our platform! — {sender}"

send_welcome = partial(send_message, welcome_template, sender=#22c55e">"The Team")

print(send_welcome(recipient=#22c55e">"Priya"))
print(send_welcome(recipient=#22c55e">"Arjun"))

send_welcome has the template and sender fixed. Only recipient changes per call. partial eliminates repetitive argument passing without creating a whole new function.

`lru_cache` — Memoisation

lru_cache (Least Recently Used cache) is a decorator that automatically caches a function's return values. When called with the same arguments again, it returns the cached result instantly — without rerunning the function.

Python

Ctrl+Enter to run

from functools import lru_cache

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

start = time.time()
print(fibonacci(35))
print(f#22c55e">"First call: {time.time() - start:.4f}s")

start = time.time()
print(fibonacci(35))
print(f#22c55e">"Second call: {time.time() - start:.6f}s")

The first call computes all intermediate Fibonacci values and caches them. The second call returns the result immediately from cache. The time difference is dramatic.

Without lru_cache, fibonacci(35) makes over 29 million recursive calls. With it, each unique n is computed exactly once.

maxsize=128 limits the cache to 128 entries — the least recently used entries are evicted when the cache is full. maxsize=None gives an unlimited cache (also available as @cache in Python 3.9+).

Python

Ctrl+Enter to run

from functools import lru_cache

@lru_cache(maxsize=None)
def count_ways(n, step_sizes=(1, 2)):
if n == 0:
return 1
if n < 0:
return 0
return sum(count_ways(n - step) for step in step_sizes)

print(count_ways(10))
print(count_ways(20))
print(count_ways.cache_info())

cache_info() reports hits, misses, current size, and maximum size — useful for understanding how effectively the cache is being used.

One constraint: lru_cache only works with hashable arguments. Lists and dictionaries cannot be cached over — use tuples instead (as shown with step_sizes).

`reduce` — Accumulating a Result

functools.reduce applies a function cumulatively to a sequence, reducing it to a single value.

Python

Ctrl+Enter to run

from functools import reduce

numbers = [1, 2, 3, 4, 5]

total = reduce(lambda acc, n: acc + n, numbers)
product = reduce(lambda acc, n: acc * n, numbers)

print(total)
print(product)

reduce(f, [a, b, c, d]) computes f(f(f(a, b), c), d). Each step takes the accumulated result and the next item and produces a new accumulated result.

An optional initial value makes the starting point explicit:

Python

Ctrl+Enter to run

from functools import reduce

words = [#22c55e">"Python", "is", "powerful"]

sentence = reduce(lambda acc, w: acc + #22c55e">" " + w, words, "")
print(sentence.strip())

# Finding the longest word

longest = reduce(lambda a, b: a if len(a) >= len(b) else b, words)
print(longest)

Be honest about when reduce is the right tool. For simple sums and products, the built-in sum() and math.prod() are clearer. reduce earns its place when you need a custom accumulation that doesn't fit neatly into built-ins — finding a maximum by a custom key, building a nested structure, composing transformations.

`total_ordering` — Completing Comparison Methods

You met this briefly in the dunder methods lesson. total_ordering is a class decorator that fills in missing comparison methods given __eq__ and one of __lt__, __le__, __gt__, or __ge__:

Python

Ctrl+Enter to run

from functools import total_ordering

@total_ordering
class Version:
def **init**(self, major, minor, patch):
self.major = major
self.minor = minor
self.patch = patch

    def __eq__(self, other):
        return (self.major, self.minor, self.patch) == (other.major, other.minor, other.patch)

    def __lt__(self, other):
        return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)

    def __repr__(self):
        return f#22c55e">"v{self.major}.{self.minor}.{self.patch}"

versions = [Version(2, 1, 0), Version(1, 9, 3), Version(2, 0, 0), Version(1, 9, 10)]
print(sorted(versions))
print(max(versions))
print(Version(2, 1, 0) >= Version(2, 0, 0))

You defined __eq__ and __lt__. total_ordering derived __le__, __gt__, and __ge__ automatically. All six comparison operators work. sorted() and max() work.

The tuple comparison (major, minor, patch) < (other.major, other.minor, other.patch) is elegant — Python compares tuples element by element, naturally implementing semantic versioning logic.

Composing Functions

A functional pattern worth knowing: building a pipeline where the output of one function feeds into the next.

Python

Ctrl+Enter to run

from functools import reduce

def compose(*functions):
def apply(value):
return reduce(lambda v, f: f(v), reversed(functions), value)
return apply

def double(x): return x * 2
def add_ten(x): return x + 10
def square(x): return x ** 2

transform = compose(double, add_ten, square)
print(transform(3)) # square(3)=9, add_ten(9)=19, double(19)=38

compose(f, g, h) returns a function that applies h first, then g, then f — right to left, matching mathematical function composition. This is a pattern from functional programming that appears in data pipelines, middleware stacks, and transformation chains.

What You Have Learned

functools provides the tools for composing, specialising, and optimising functions in a clean, reusable way.

The key ideas:

partial(func, *args, **kwargs) — creates a new function with some arguments pre-filled
lru_cache(maxsize=n) — memoises a function's results; transformative for recursive algorithms
lru_cache requires hashable arguments — use tuples, not lists
reduce(func, iterable, initial) — folds a sequence into a single accumulated value
total_ordering — derive all six comparison operators from just __eq__ and one other
Function composition — building pipelines by chaining small, pure functions

In the next lesson, you'll learn regular expressions — Python's tool for finding, extracting, and transforming text by pattern rather than by exact match.

Functional Tools

Functional Programming in Python

partial — Pre-filling Arguments

lru_cache — Memoisation

reduce — Accumulating a Result

total_ordering — Completing Comparison Methods

Composing Functions

What You Have Learned

`partial` — Pre-filling Arguments

`lru_cache` — Memoisation

`reduce` — Accumulating a Result

`total_ordering` — Completing Comparison Methods