Saltearse al contenido

Funciones como objetos

En C una función es una dirección de código. En Python es un objeto con tipo, atributos y contador de referencias, igual que un entero. Esa diferencia es la que permite pasar str.upper como argumento, guardar diez funciones en un diccionario y devolver una función desde otra. Todo lo demás de esta parte se construye sobre esa base.

Una función no es un bloque de código al que se llama: es un objeto que, entre otras cosas, se puede llamar.

def saludar(nombre):
return f"hola {nombre}"
type(saludar) # <class 'function'>
saludar.__name__ # 'saludar'
saludar.__doc__ # None
id(saludar) # una dirección, como cualquier objeto
otra = saludar # no copia: otro nombre para el mismo objeto
otra is saludar # True

Igual que en el capítulo 03 de la Parte I, otra = saludar no copia nada. Y como cualquier objeto, cabe en una estructura:

operaciones = {
"+": lambda a, b: a + b,
"-": lambda a, b: a - b,
"*": lambda a, b: a * b,
}
operaciones["+"](2, 3) # 5

Ese diccionario es un intérprete de expresiones de tres líneas, y no necesita if/elif. Es el patrón que en otros lenguajes requiere un switch o un mapa de punteros.

Cuatro operaciones, y todas funcionan:

Operación Ejemplo
Asignar a un nombre f = saludar
Guardar en una estructura d["saludo"] = saludar
Pasar como argumento sorted(datos, key=len)
Devolver desde otra función return decorador(f)

La cuarta es la que define a los decoradores, y por eso el capítulo 03 empieza donde termina este.

Una función que recibe o devuelve funciones se llama de orden superior, y la biblioteca estándar está llena:

sorted(palabras, key=str.lower) # recibe una función
list(map(str.strip, lineas)) # recibe una función
max(filas, key=lambda f: f.importe) # recibe una función

key= es el caso más importante: no ordena por el valor de la función, ordena por el resultado de aplicarla. Es una diferencia que confunde al principio y que explica por qué key=len ordena por longitud y no por identidad.

Cualquier objeto con __call__ se puede llamar como una función:

class Multiplicador:
def __init__(self, factor):
self.factor = factor
def __call__(self, x):
return x * self.factor
doble = Multiplicador(2)
doble(5) # 10
callable(doble) # True

La diferencia con una clausura es el estado: una instancia guarda sus atributos y puede inspeccionarse, heredarse y serializarse. Un lambda guarda su clausura y nada más.

Coste de leer una variable según su ámbito
Ámbito Por lectura
Local 23.1 ns
Cierre (clausura) 25.2 ns
Global 27.4 ns
Builtin (len) 37.6 ns

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

Es la regla LEGB medida: local, enclosing, global, builtin. La diferencia entre local y global es de 4 nanosegundos, así que la vieja optimización de «pasar las globales como locales» sólo importa en bucles de millones. Lo que sí importa es que el intérprete mira en cuatro sitios antes de rendirse, y que un nombre mal escrito en una función no falla hasta que esa línea se ejecuta.

Las funciones tienen atributos, y eso se usa

Sección titulada «Las funciones tienen atributos, y eso se usa»

Una función admite atributos arbitrarios, y la biblioteca estándar los aprovecha:

def procesar(x):
return x * 2
procesar.llamadas = 0 # atributo propio
procesar.llamadas += 1

Ese truco es exactamente cómo funciona functools.lru_cache: guarda el diccionario de resultados en un atributo de la función envuelta. Y es cómo muchos frameworks registran metadatos (@app.route deja f.url_rule).

La advertencia: los atributos viven en la función, no en el módulo, así que dos funciones distintas no comparten estado. Si necesitas estado compartido, es un objeto, no una función con adornos.

  • Si una comprensión se lee mejor. [f(x) for x in datos] es más claro que list(map(f, datos)), y casi igual de rápido.
  • Si el lambda no cabe en una línea. Una función con nombre documenta; un lambda de tres líneas no existe (es un error de sintaxis).
  • Si el estado importa. Cuando la función necesita recordar algo entre llamadas, una clase con __call__ o un functools.partial es más honesto que un nonlocal escondido.

Escribe un despachador que, dado un nombre de operación y dos números, ejecute la operación correcta sin usar if/elif. Después explica qué ventaja tiene frente a la cadena de condiciones cuando hay veinte operaciones.

Solución
import operator
OPERACIONES = {
"suma": operator.add,
"resta": operator.sub,
"producto": operator.mul,
"division": operator.truediv,
}
def calcular(nombre, a, b):
try:
operacion = OPERACIONES[nombre]
except KeyError:
raise ValueError(f"operación desconocida: {nombre}") from None
return operacion(a, b)

Ventajas con veinte operaciones: el diccionario es datos, no control; se puede inspeccionar (OPERACIONES.keys()), ampliar desde otro módulo y probar sin tocar la función. La cadena de elif crece linealmente y hay que modificarla para cada caso nuevo.

El detalle del raise ... from None es deliberado: oculta el KeyError interno para que el error que ve el usuario sea el mensaje de negocio.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 7: Functions as First-Class Objects.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Capítulo 3.
  • Mediciones: mediciones/03-01-04-funciones.py.
  • 02 · Clausuras: qué guarda una función cuando se crea dentro de otra.
  • 03 · Decoradores: la consecuencia directa de poder devolver funciones.
  • 09 · El protocolo de llamada: __call__ en profundidad.