Python functools Module

reduce(function, iterable, initial) repeatedly applies a two-argument function to an accumulator and each successive item of the iterable, folding the whole sequence down to one final value — reduce(lambda acc, x: acc + x, [1,2,3,4,5], 0) computes ((((0+1)+2)+3)+4)+5, step by step, ending at 15. This is precisely the general mechanism that Python's built-in sum() implements as a specific, optimized case; reduce generalizes the same 'fold' pattern to any binary operation, not just addition.

reduce is genuinely useful, but it's worth knowing it sits at the more general, less-readable end of Python's functional toolkit — for the extremely common cases of summing, finding a max/min, or concatenating, the dedicated built-ins (sum(), max(), min(), "".join()) are more readable and usually just as fast, since reduce with a lambda obscures the specific operation behind generic accumulator syntax. reduce earns its place for genuinely custom fold operations — accumulating into a more complex structure, or applying a domain-specific combining function that has no dedicated built-in.

The initial argument (the third one, 0 and 1 in the examples) matters for two reasons: it defines the starting value for the accumulator, and it makes reduce behave sensibly on an empty iterable (returning the initial value directly) rather than raising TypeError: reduce() of empty iterable with no initial value, which is what happens if you omit it and the iterable turns out to be empty.

partial(power, exponent=2) returns a new callable — not a result, a *function-like object* — that, when eventually called, invokes power with exponent already fixed to 2, needing only the remaining argument (base) to be supplied at call time. This is directly useful anywhere an API expects a callable with a specific, fixed signature (a one-argument function, say, for a callback or a map() call), but the function you actually want to use takes more arguments than that — partial lets you adapt the shape without writing a small wrapper def by hand.

This connects directly back to the Strategy Pattern from the Design Patterns lesson: partial is frequently how you construct a specific 'strategy' instance from a more general, parameterized function — square and cube are both derived from the same underlying power logic, specialized for a specific use, in one line each, without duplicating any of power's implementation.

partial also supports pre-filling *positional* arguments (partial(power, 2) fixes base to 2 instead), and the resulting partial object exposes .func, .args, and .keywords attributes if you ever need to introspect exactly what was pre-filled — useful for debugging or for tooling that needs to inspect a partial's configuration rather than just call it.

@lru_cache(maxsize=None) wraps a function so that every unique combination of arguments it's called with has its return value stored (memoized) after the first computation — every subsequent call with that exact same set of arguments returns the cached result instantly, skipping recomputation entirely. This is precisely why fibonacci(35), naively recursive and otherwise exponentially slow (recomputing the same sub-values an enormous number of times), becomes fast: each unique n is computed exactly once, ever, across the entire call tree, and every repeated call just looks it up.

maxsize=None means the cache grows unbounded, which is fine for a pure function like Fibonacci with a naturally small, bounded domain of realistic inputs, but is a genuine memory consideration for a function called with a huge or unbounded variety of argument values — maxsize=128 (the default) evicts the least-recently-used entries once the cache is full, bounding memory at the cost of occasionally recomputing a value that fell out of the cache. lru_cache requires every argument to be hashable, since it uses them as a dict key internally — a function taking a list argument cannot be cached directly without converting to a hashable type like a tuple first.

@singledispatch solves a different problem: writing one function whose *behavior* varies by the runtime type of its first argument, without a manual if isinstance(value, int): ... elif isinstance(value, list): ... chain. Each @describe.register-decorated function handles one specific type, and calling describe(x) automatically dispatches to whichever registered implementation matches type(x) — a clean, extensible alternative (new types register their own handler without modifying describe itself, an application of the Open/Closed Principle from the SOLID lesson) to a growing isinstance chain.

reduce(), partial(), and lru_cache() are three of the most reused tools in professional Python, each solving a different 'do something to/with a function' problem. Let's meet them.

reduce() folds an iterable down to a single value by repeatedly applying a function -- it's the general case behind sum(), and behind writing your own accumulator loops.

partial() pre-fills some arguments of a function, returning a new callable that only needs the rest -- useful for adapting a function's signature to fit an API.

Checkpoint: What does square = partial(power, exponent=2) actually create?

• →A new callable that calls power() with exponent already fixed to 2, needing only base
• →The immediate result of calling power(exponent=2), i.e. a number

lru_cache() memoizes a function's results -- repeated calls with the same arguments skip recomputation entirely, trading memory for speed.

Checkpoint: Why does @lru_cache make repeated calls to fibonacci(35) fast, when the naive recursive version is extremely slow?

• →It memoizes results — each unique argument value is computed once and reused on every subsequent call
• →It automatically parallelizes the recursive calls across CPU cores

singledispatch lets a function behave differently based on the TYPE of its first argument -- a lightweight alternative to a chain of isinstance checks.

functools rounds out the functional-programming toolkit — datetime shifts focus to the specific domain of handling dates and times correctly.

Fold Real Data with reduce. Finish product_of(): reduce() folds an iterable down to a single value.