Unlock Python’s Power: 8 Essential functools Tools You Must Know

functools is a powerful module in Python’s standard library that provides a suite of functional programming tools, primarily used to enhance or manipulate callable objects such as functions, improving code reuse and readability.

1. functools.reduce(function, iterable[, initializer])

Function: accumulate elements of an iterable (reduction).

<code>from functools import reduce
# accumulate all numbers
result = reduce(lambda x, y: x + y, [1, 2, 3, 4])
print(result)  # Output: 10
# using initializer
result = reduce(lambda x, y: x + y, [1, 2, 3], 10)
print(result)  # Output: 16</code>

2. functools.partial(func, *args, **keywords)

Function: fix part of a function’s arguments, returning a new partially applied function.

<code>from functools import partial
def power(base, exponent):
    return base ** exponent
square = partial(power, exponent=2)
cube = partial(power, exponent=3)
print(square(5))  # Output: 25
print(cube(5))    # Output: 125</code>

3. functools.lru_cache(maxsize=128)

Function: cache function results to avoid repeated computation, especially useful for recursive or expensive functions. Suitable for idempotent functions (same input always yields same output).

<code>from functools import lru_cache
@lru_cache(maxsize=None)  # no limit on cache size
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)
print(fib(100))  # Very fast because intermediate results are cached</code>

4. functools.wraps(wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)

Function: preserve a wrapped function’s metadata (e.g., __name__, __doc__) when writing decorators.

<code>from functools import wraps
def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper
@my_decorator
def say_hello():
    """Greet the user."""
    print("Hello")
print(say_hello.__name__)  # Output: say_hello
print(say_hello.__doc__)   # Output: Greet the user.</code>

5. functools.total_ordering()

Function: automatically generate all rich comparison methods (<, <=, >, >=) for a class by defining __eq__ and one other comparison method.

<code>from functools import total_ordering
@total_ordering
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __eq__(self, other):
        return self.age == other.age
    def __lt__(self, other):
        return self.age < other.age
p1 = Person("Alice", 30)
p2 = Person("Bob", 25)
print(p1 > p2)  # True
print(p1 < p2)  # False</code>

6. functools.cmp_to_key(func)

Function: convert an old‑style comparison function (returning -1, 0, 1) into a key function usable by sorted().

<code>from functools import cmp_to_key
def compare(a, b):
    if a < b:
        return -1
    elif a > b:
        return 1
    else:
        return 0
nums = [5, 2, 9, 1]
sorted_nums = sorted(nums, key=cmp_to_key(compare))
print(sorted_nums)  # Output: [1, 2, 5, 9]</code>

7. functools.singledispatch

Function: overload a function based on the type of its first argument, enabling simple polymorphism.

<code>from functools import singledispatch
@singledispatch
def process(data):
    print("Default handling:", data)
@process.register(int)
def _(data):
    print("Handling int:", data * 2)
@process.register(str)
def _(data):
    print("Handling str:", data.upper())
process(10)        # Output: Handling int: 20
process("abc")    # Output: Handling str: ABC
process([1, 2])   # Output: Default handling: [1, 2]</code>

8. functools.cache (Python 3.9+)

Function: similar to lru_cache(None) but more efficient for functions without parameters or with immutable arguments.

<code>from functools import cache
@cache
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n-1)
print(factorial(100))  # Fast computation without repeated work</code>

Summary Table: Common functools Utilities