Saltearse al contenido

functools

functools es el módulo de las funciones de orden superior que ya están escritas. Cinco de sus herramientas se usan a diario en código de producción: lru_cache, partial, singledispatch, reduce y wraps. Las cinco son decoradores o fábricas de funciones, así que el capítulo anterior es el requisito.

Antes de escribir un envoltorio, mira si functools ya lo tiene: casi siempre lo tiene.

Fibonacci de 20, con y sin caché
Versión Tiempo Acierto de caché
Recursiva sin caché 1.114 ms —
Con lru_cache ~0 ms 41 ns

python mediciones/03-01-04-funciones.py

La recursiva sin caché recalcula fib(18) decenas de veces; con caché, cada valor se calcula una vez. El cambio es de cinco mil veces en un problema de veinte, y la brecha crece exponencialmente con n.

from functools import lru_cache
@lru_cache(maxsize=128)
def fib(n: int) -> int:
return n if n < 2 else fib(n - 1) + fib(n - 2)
fib.cache_info() # hits, misses, maxsize, currsize
fib.cache_clear()

maxsize=None equivale a @cache (3.9+) y crece sin límite. maxsize=128 guarda las 128 llamadas más recientes y descarta el resto por LRU.

La clave de caché son los argumentos: la función se identifica por su combinación. Eso implica que todos los argumentos deben ser hashables, y que dos llamadas con el mismo valor devuelven el mismo objeto cacheado —incluido si es mutable.

Un millón de llamadas
Forma Coste
functools.partial(f, 1)(2) 35 ns
lambda x: f(1, x)(2) 50 ns

python mediciones/03-01-04-funciones.py

Un 42 % más rápido que la lambda equivalente, y con mejor introspección (p.func, p.args). Se usa para adaptar firmas:

from functools import partial
import json
cargar = partial(json.load, parse_float=Decimal)

También sirve para sorted(key=...) cuando la clave necesita un parámetro extra: sorted(datos, key=partial(calcular_peso, factor=2)).

from functools import singledispatch
@singledispatch
def formatear(valor):
return str(valor)
@formatear.register
def _(valor: int):
return f"{valor:,}"
@formatear.register
def _(valor: list):
return ", ".join(map(str, valor))

Es la alternativa a una cadena de isinstance. La ventaja no es el rendimiento —la búsqueda es un diccionario por tipo— sino que cada tipo se registra en su propio bloque, y un módulo externo puede añadir el suyo sin tocar el original. Es polimorfismo sin herencia.

from functools import reduce
from operator import add
reduce(add, [1, 2, 3, 4]) # 10

Casi siempre hay algo mejor: sum para sumar, math.prod para multiplicar, una comprensión para transformar. reduce gana cuando la operación no existe como builtin y no se lee peor como bucle. En la práctica, se usa poco y se lee mal: la guía de estilo de Python lo desaconseja salvo que el patrón sea obvio.

Desde 3.9 existe @cache, que es azúcar para lru_cache(maxsize=None). La diferencia práctica no es el comportamiento sino la intención: @cache dice «esto no tiene límite» y @lru_cache(maxsize=128) dice «acoto la memoria». Elegir uno u otro es documentar qué esperas del dominio de entrada.

Y @cached_property resuelve otro problema: cachear el resultado de un cálculo por instancia, no por argumentos.

from functools import cached_property
class Informe:
@cached_property
def total(self):
return sum(self.lineas) # se calcula una vez por objeto

Es el patrón correcto para propiedades caras: la primera lectura calcula, las siguientes devuelven el atributo guardado en __dict__. No sirve para clases con __slots__, precisamente porque necesita ese diccionario.

  • lru_cache sobre funciones con efectos. Si lee un archivo o consulta una base, cachear congela el primer resultado y oculta los cambios.
  • partial cuando un default hace lo mismo. def f(x, factor=2) es más claro que partial(f, factor=2) y se puede inspeccionar mejor.
  • reduce para sumar o multiplicar. sum y math.prod existen.
  • singledispatch con dos tipos. Un if isinstance de dos ramas se lee mejor; el despacho empieza a pagar a partir de cuatro o cinco.

Una función precio_final(producto, pais) tarda 200 ms porque consulta una API de impuestos. Se llama miles de veces con los mismos veinte países. Escribe la versión con caché y explica qué pasa si mañana cambian los impuestos de un país.

Solución
from functools import lru_cache
@lru_cache(maxsize=64)
def precio_final(producto, pais):
return consultar_api(producto, pais)

maxsize=64 cubre los veinte países con margen y acota la memoria si mañana hay doscientos.

El problema del cambio de impuestos es real: la caché devuelve el valor viejo hasta que se reinicia el proceso. Tres soluciones, en orden de simplicidad:

  1. cache_clear() programado cuando se sabe que los tipos cambiaron (un evento, un cron).
  2. Incluir la versión de la tabla en la clave: precio_final(producto, pais, version_tarifas). Cuando cambia la versión, cambia la clave y la caché vieja se descarta sola.
  3. TTL explícito con cachetools.TTLCache, si la dependencia externa cambia sin avisar.

La lección: cachear no es una optimización transparente, es una decisión sobre cuánto tiempo puede estar equivocado un dato.

Comprobación con datos de ejemplo:

llamadas = []
def consultar_api(producto, pais):
llamadas.append((producto, pais))
return round(100 * (1.16 if pais == "MX" else 1.21), 2)
precio_final.cache_clear()
for _ in range(1000):
precio_final("viga", "MX")
precio_final("viga", "ES")
print("llamadas reales a la API:", len(llamadas))
print(precio_final.cache_info())
precio_final.cache_clear()
precio_final("viga", "MX")
print("tras cache_clear:", len(llamadas))
assert len(llamadas) == 3, "dos paises y una repeticion tras limpiar"
  • Ramalho, L. Fluent Python, 2ª ed. Capítulos 7 y 9.
  • CPython 3.13: Modules/_functoolsmodule.c.
  • Mediciones: mediciones/03-01-04-funciones.py.
  • 03 · Decoradores: lru_cache es un decorador con parámetros.
  • 09 · El protocolo de llamada: partial como objeto con __call__.
  • 07 · Expresiones generadoras y pereza: cuándo la caché es peor que no calcular.