**`functools` — the functional programming toolkit**
The `functools` module provides higher-order functions — functions that operate on or return other functions. These patterns appear constantly in professional Python code: caching, partial application, composing comparisons.
**`@lru_cache` — memoization with a size limit**
LRU (Least Recently Used) cache stores the results of function calls. When the same arguments are passed again, the cached result is returned instantly instead of re-computing:
```python
from functools import lru_cache
@lru_cache(maxsize=128)
def fibonacci(n):
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
fibonacci(100) # computed once; subsequent calls instant
fibonacci.cache_info() # CacheInfo(hits=98, misses=101, maxsize=128, currsize=101)
fibonacci.cache_clear() # invalidate the cache
```
The cache key is built from the arguments, so all arguments must be hashable (no lists or dicts). `maxsize=None` means unlimited — equivalent to `@cache`.
**`@cache` (Python 3.9+) — unbounded memoization**
```python
from functools import cache
@cache
def count_ways(n, k):
if n == 0: return 1
if n < 0 or k == 0: return 0
return count_ways(n - k, k) + count_ways(n, k - 1)
```
`@cache` is simpler and slightly faster than `@lru_cache(maxsize=None)` because it doesn't track LRU order.
**`@cached_property` — compute once per instance**
A regular `@property` re-runs its getter every time. `@cached_property` runs the getter once and stores the result as an instance attribute:
```python
from functools import cached_property
class DataSet:
def __init__(self, raw):
self.raw = raw
@cached_property
def sorted_data(self):
print('computing...')
return sorted(self.raw)
ds = DataSet([3, 1, 2])
ds.sorted_data # 'computing...' printed
ds.sorted_data # nothing printed — cached as ds.__dict__['sorted_data']
```
Note: `cached_property` only works on instances that have a `__dict__`. Classes using `__slots__` must use `lru_cache` on methods instead.
partial, reduce, compose pattern, cmp_to_key, and @wraps
**`@total_ordering` — define one comparison, get the rest**
If you define `__eq__` and one of `__lt__`, `__le__`, `__gt__`, `__ge__`, `@total_ordering` fills in the remaining comparison methods:
```python
from functools import total_ordering
@total_ordering
class Version:
def __init__(self, major, minor):
self.major = major
self.minor = minor
def __eq__(self, other):
return (self.major, self.minor) == (other.major, other.minor)
def __lt__(self, other): # only need to define __lt__
return (self.major, self.minor) < (other.major, other.minor)
v1 = Version(1, 9)
v2 = Version(1, 10)
v1 < v2 # True
v1 > v2 # False — generated by @total_ordering
v2 >= v1 # True — generated by @total_ordering
sorted([v2, v1]) # [Version(1,9), Version(1,10)]
```
**`@singledispatch` — function overloading by type**
`singledispatch` lets you write different implementations of a function that are chosen based on the type of the first argument:
```python
from functools import singledispatch
@singledispatch
def process(value):
raise NotImplementedError(f'No handler for {type(value)}')
@process.register(int)
def _(value):
return value * 2
@process.register(str)
def _(value):
return value.upper()
@process.register(list)
def _(value):
return [process(item) for item in value]
process(5) # 10
process('hello') # 'HELLO'
process([1, 'a', 2]) # [2, 'A', 4]
```
**Quick reference — all functools**
| Function | Purpose |
|---|---|
| `@lru_cache(maxsize=N)` | Cache results; evicts LRU when full |
| `@cache` | Same but unbounded (3.9+) |
| `@cached_property` | Compute once per instance |
| `partial(func, *args, **kw)` | Pre-fill arguments |
| `reduce(func, iterable)` | Fold sequence to one value |
| `cmp_to_key(cmp_fn)` | Adapt old comparison to key function |
| `@wraps(func)` | Copy metadata through decorators |
| `@total_ordering` | Generate comparison methods from eq + one |
| `@singledispatch` | Type-based function overloading |
Use `functools.partial` to create two specialized functions from `power(base, exp)`: `square(n)` which is `power(n, 2)`, and `cube(n)` which is `power(n, 3)`. Also create `add5 = partial(operator.add, 5)` that adds 5 to any number.
Use `@functools.lru_cache(maxsize=None)` to memoize a recursive `fib(n)` function. Print `fib(35)`. Then use `fib.cache_info()` to show how many hits vs misses occurred. Without caching, `fib(35)` would make ~29 million calls.
import functools
# Add lru_cache decorator here
def fib(n: int) -> int:
if n < 2:
return n
return fib(n - 1) + fib(n - 2)
print(fib(35)) # 9227465
print(fib.cache_info()) # CacheInfo(hits=..., misses=36, ...)
Create a class `Circle` with `radius: float`. Add an `area` attribute using `@functools.cached_property` that computes `math.pi * radius ** 2`. Verify that accessing `area` twice returns the same value without recomputing (add a `print('computing...')` inside to see it only prints once).
import math
import functools
class Circle:
def __init__(self, radius: float) -> None:
self.radius = radius
# Add cached_property for area here
c = Circle(5)
print(c.area) # computing... then 78.539...
print(c.area) # 78.539... (no 'computing...' this time)
Solution
import math
import functools
class Circle:
def __init__(self, radius: float) -> None:
self.radius = radius
@functools.cached_property
def area(self) -> float:
print('computing...')
return math.pi * self.radius ** 2
c = Circle(5)
print(c.area) # computing... then 78.539...
print(c.area) # 78.539... (no 'computing...')
Use `@functools.total_ordering` to create a `Version` class with `major, minor, patch` fields. Define only `__eq__` and `__lt__`. The decorator will auto-generate `__le__`, `__gt__`, `__ge__`. Test that all comparisons work.
Use `@functools.singledispatch` to write a `describe(value)` function that has different implementations for `int`, `str`, `list`, and a default for other types. int: `f'Integer: {value}'`, str: `f'String of length {len(value)}'`, list: `f'List with {len(value)} items'`, default: `f'Unknown type: {type(value).__name__}'`.
import functools
@functools.singledispatch
def describe(value) -> str:
pass # default implementation
# Register int, str, list implementations here
print(describe(42)) # Integer: 42
print(describe('hello')) # String of length 5
print(describe([1, 2, 3])) # List with 3 items
print(describe(3.14)) # Unknown type: float
Use `functools.reduce` to implement three operations without built-in functions: `product(nums)` — product of all numbers, `my_max(nums)` — maximum value, `flatten_str(words)` — join words with a space.
import functools
nums = [2, 3, 4, 5]
words = ['Hello', 'world', 'from', 'reduce']
product = functools.reduce(lambda a, b: a * b, nums)
print(product) # 120
my_max = functools.reduce(lambda a, b: a if a > b else b, nums)
print(my_max) # 5
flatten_str = functools.reduce(lambda a, b: a + ' ' + b, words)
print(flatten_str) # Hello world from reduce
Solution
import functools
nums = [2, 3, 4, 5]
words = ['Hello', 'world', 'from', 'reduce']
product = functools.reduce(lambda a, b: a * b, nums)
print(product) # 120
my_max = functools.reduce(lambda a, b: a if a > b else b, nums)
print(my_max) # 5
flatten_str = functools.reduce(lambda a, b: a + ' ' + b, words)
print(flatten_str) # Hello world from reduce
Write a decorator `log_calls` that prints `'Calling <func_name>'` before calling the wrapped function. Use `@functools.wraps(func)` inside so that the wrapper preserves the original function's `__name__` and `__doc__`. Verify that `decorated.__name__` is the original name, not `'wrapper'`.
Write a function `slow_square(n)` that simulates a slow computation (print `f'Computing {n}^2'` then return `n*n`). Apply `@lru_cache(maxsize=3)` so only the 3 most recent results are cached. Call `slow_square` with 1, 2, 3, 1 (cached), 4 (evicts 2), 2 (recomputed).
Use `functools.partial` to create a reusable `sort_by_field(items, field)` function. Then create `sort_by_age = partial(sort_by_field, field='age')` and `sort_by_name = partial(sort_by_field, field='name')`. Apply both to a list of dicts.
import functools
def sort_by_field(items, field):
return sorted(items, key=lambda x: x[field])
sort_by_age = functools.partial(sort_by_field, field='age')
sort_by_name = functools.partial(sort_by_field, field='name')
people = [
{'name': 'Charlie', 'age': 30},
{'name': 'Alice', 'age': 25},
{'name': 'Bob', 'age': 35},
]
for p in sort_by_age(people):
print(p['name'], p['age'])
# Alice 25 / Charlie 30 / Bob 35
for p in sort_by_name(people):
print(p['name'])
# Alice / Bob / Charlie
Solution
import functools
def sort_by_field(items, field):
return sorted(items, key=lambda x: x[field])
sort_by_age = functools.partial(sort_by_field, field='age')
sort_by_name = functools.partial(sort_by_field, field='name')
people = [
{'name': 'Charlie', 'age': 30},
{'name': 'Alice', 'age': 25},
{'name': 'Bob', 'age': 35},
]
for p in sort_by_age(people):
print(p['name'], p['age'])
for p in sort_by_name(people):
print(p['name'])
Combine `@singledispatch` and `@lru_cache` to write a cached `process(value)` function. The `int` implementation returns `value * 2`, the `str` implementation returns `value.upper()`, and the default returns `str(value)`. Cache the str and int implementations with `maxsize=32`.
We use necessary cookies to run the site. With your permission, we can also save your site preferences and use analytics and advertising cookies to understand usage and support the project.
Open tools in tabs.Exercises, IDE tools, and trainers stay available as site tabs.
Switch without losing context.Move between explanations, code, and utilities while keeping your place.
Use the sidebar as your map.The left panels hold navigation, settings, files, libraries, and tool controls.
PythonJavaScriptSQLite
One IDE, three practical modes
Python in the browser.Run small scripts, try libraries, and practice API requests without installing anything.
JavaScript for quick experiments.Test browser-friendly code and compare ideas next to your learning materials.
SQLite for data practice.Open the database explorer to inspect tables, write queries, and learn SQL workflows locally.
TopicIDE
Work side by side with split tabs
Keep instructions visible.Open an exercise or reference page beside the IDE instead of jumping back and forth.
Compare tools while you learn.Place regex checks, explanations, and code experiments next to each other when the task needs it.
Close the split when you are done.The workspace returns to a single focused tab, and your open site tabs remain available.
Code Typing Trainer
Or plain text
This trainer is designed for a physical keyboard.Open this section on a laptop or desktop with a wide screen. Touch typing practice will not work correctly on a phone.
Speed: 0 chars/min
0 words/min
Best speed (60s): 0 chars/min
0 words/min
Errors: 0
Total time: 0.0 s
To practice touch typing, avoid looking at your physical keyboard.