Saltearse al contenido

Composición y pipelines

Escribir f(g(h(x))) funciona hasta que hay cinco funciones, y entonces nadie sabe en qué orden se ejecutan. La composición resuelve eso: convertir una cadena de llamadas en un valor que se puede nombrar, listar, probar por partes y reordenar sin tocar el código.

Componer es pasar de «llamo a esto dentro de aquello» a «esto es la secuencia de pasos».

def componer(f, g):
def compuesta(x):
return f(g(x))
return compuesta
limpiar_y_contar = componer(len, str.strip)
limpiar_y_contar(" hola ") # 4

El orden se lee de dentro afuera: primero g, después f. Es la fuente de la mitad de los errores de composición, así que conviene nombrar la función compuesta de forma que el orden quede claro.

Para más de dos, functools.reduce:

from functools import reduce
def componer_muchas(*funciones):
return reduce(lambda f, g: lambda x: f(g(x)), funciones)
Aplicar dos transformaciones a 1 000 elementos
Forma Tiempo Frente a anidar
doblar(sumar_uno(i)) en el generador 93.0 µs 1.00×
Función compuesta compuesta(i) 112.6 µs 1.21×

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

Un 21 % por elemento: cada nivel de composición añade una llamada. En un pipeline de tres o cuatro pasos sobre un millón de filas, la diferencia deja de ser anecdótica. La regla: compón para leer, no para acelerar, y si el perfil señala el pipeline, desenróllalo en el punto caliente.

Para datos, la composición natural no es de funciones sino de generadores: cada etapa consume la anterior y produce para la siguiente.

def limpio(lineas):
for l in lineas:
l = l.strip()
if l and not l.startswith("#"):
yield l
def numeros(lineas):
for l in limpio(lineas):
try:
yield float(l)
except ValueError:
continue
total = sum(numeros(open("datos.txt", encoding="utf-8")))

Cada función es testeable por separado, y la memoria es la de una línea. Ese es el patrón que usan csv, json y casi cualquier procesamiento de datos en Python.

El patrón opuesto —envolver en lugar de encadenar— es el de middleware:

def con_log(f):
@functools.wraps(f)
def envoltorio(*a, **k):
print(f"-> {f.__name__}")
return f(*a, **k)
return envoltorio
def con_reintentos(f):
...

Aplicarlos en orden produce una cebolla: cada capa envuelve a la anterior. Es el modelo de Django, de las apps ASGI y de los decoradores apilados del capítulo 03.

  • Con dos pasos, escríbelos seguidos: resultado = f(g(x)) se lee perfectamente y no necesita abstracción.
  • Si el orden importa para el rendimiento, componer añade un 20 % por elemento; desenrolla el punto caliente.
  • Si cada etapa tiene parámetros distintos, un diccionario de configuración o una clase con métodos se lee mejor que una lista de partial.
  • En bucles internos de millones de iteraciones, el pipeline de generadores es elegante y más lento que un solo bucle con tres operaciones dentro.

Escribe un pipeline que lea un CSV, descarte filas con precio vacío, convierta el precio a Decimal y devuelva la suma. Después explica qué etapa cambiarías si el archivo tuviera cinco millones de filas.

Solución
import csv
from decimal import Decimal, InvalidOperation
def filas(ruta):
with open(ruta, encoding="utf-8", newline="") as f:
yield from csv.DictReader(f)
def con_precio(filas_):
for fila in filas_:
if fila.get("precio"):
yield fila
def a_decimal(filas_):
for fila in filas_:
try:
yield Decimal(fila["precio"])
except InvalidOperation:
continue
import os
import tempfile
ruta = os.path.join(tempfile.gettempdir(), "datos.csv")
with open(ruta, "w", newline="", encoding="utf-8") as salida:
salida.write("nombre,precio\nlibro,10.50\nlapiz,\nmesa,20.00\n")
total = sum(a_decimal(con_precio(filas(ruta))))
print(total)

Con cinco millones de filas no cambia nada: el pipeline ya procesa de una en una y la memoria es constante. Lo que sí habría que revisar es el csv.DictReader (crea un diccionario por fila, capítulo 09 de la Parte II) y la suma de Decimal, que cuesta 56 ns por elemento frente a 7 de float.

Si el total no necesita exactitud decimal, cambiar Decimal por float multiplica la velocidad por ocho. Si la necesita, el coste es el precio de la corrección.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulos 7 y 10: funciones de orden superior y patrones.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Capítulo 9: programación funcional.
  • Mediciones: mediciones/03-09-11-llamada-tipos.py.
  • 06 · Generadores: el motor de los pipelines de datos.
  • 03 · Decoradores: la composición de envoltorios.
  • 04 · functools: partial y reduce como piezas de composición.