Saltearse al contenido

El protocolo de llamada

callable(x) no pregunta si x es una función: pregunta si se puede llamar. Cualquier objeto con __call__ lo es, y eso incluye clases, métodos, functools.partial y cualquier instancia tuya. Es el mecanismo que permite pasar «algo que se ejecuta» sin comprometerse a que sea una función.

Si un objeto se llama, es una función a efectos de contrato; lo que cambia es lo que lleva dentro.

Un millón de llamadas con un argumento
Forma Coste
funcion(x) 54 ns
objeto(x) con __call__ 98 ns
metodo_ligado(x) 57 ns
instancia.metodo(x) 57 ns

python mediciones/03-09-11-llamada-tipos.py

Un objeto con __call__ cuesta 1,8 veces una función: la llamada pasa por type(obj).__call__, que es un método de la clase, y eso añade una indirección. Un método ligado cuesta lo mismo que una función porque desde 3.11 el intérprete especializa el patrón.

La diferencia de 44 nanosegundos es irrelevante por llamada y decisiva en un bucle de cien millones. Como siempre: el contrato primero, el número después.

class Reintentador:
def __init__(self, veces=3, espera=0.5):
self.veces = veces
self.espera = espera
self.intentos = 0
def __call__(self, f):
...

Frente a una clausura, el objeto gana cuando:

  • Necesitas varios métodos (reset(), estadisticas()), no sólo llamarlo.
  • El estado debe ser inspeccionable o configurable después de crearlo.
  • Necesitas heredar o registrarlo por tipo.
  • Quieres serializarlo o pasarlo entre procesos.

La clausura gana cuando sólo hay una operación y el estado es un detalle privado.

callable(int) # True — int(...) crea una instancia
callable(len) # True — es una función de C
callable("texto") # False

Llamar a una clase ejecuta __new__ y luego __init__. Eso explica por qué una clase se puede pasar donde se espera una fábrica: defaultdict(list) recibe la clase list como fábrica y la llama cuando falta la clave.

  • Si basta una función. Una función con nombre es más simple y más rápida.
  • Si el estado es un contador. itertools.count() o un atributo de clase se leen mejor.
  • Si el objeto se llama una vez. Crear una clase para una llamada es ceremonia.
  • Si la API espera una función. Muchos frameworks comprueban inspect.isfunction y rechazan instancias callables; en ese caso hay que envolver.

Escribe un objeto Temporizador que se pueda llamar con una función y devuelva su resultado, acumulando cuántas veces se ha llamado y el tiempo total. Después explica por qué no conviene hacerlo con una clausura.

Solución
import time
class Temporizador:
def __init__(self):
self.llamadas = 0
self.total = 0.0
def __call__(self, f, *args, **kwargs):
inicio = time.perf_counter()
try:
return f(*args, **kwargs)
finally:
self.total += time.perf_counter() - inicio
self.llamadas += 1
def funcion(x):
return x * 2
t = Temporizador()
print(t(funcion, 1))
print(t.llamadas, f"{t.total:.6f} s")

Con una clausura, llamadas y total sólo serían accesibles como t.__closure__[0].cell_contents, y añadir estadisticas() obligaría a devolver una tupla de funciones. El objeto da estado inspeccionable, métodos con nombre y la posibilidad de heredar de él o sustituirlo en un test.

El finally es deliberado: mide también cuando la función lanza, que es cuando más interesa el dato.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 7.
  • CPython 3.13: Objects/typeobject.c (slot_tp_call), Objects/methodobject.c.
  • Mediciones: mediciones/03-09-11-llamada-tipos.py.
  • 01 · Funciones como objetos: la base del protocolo.
  • 02 · Clausuras: la alternativa ligera al objeto callable.
  • 04 · functools: partial es un callable ya hecho.