Saltearse al contenido

Declarativo, código que se lee como inglés

Durante décadas, programar consistió en decirle a la máquina cómo hacer algo: qué registro cargar, dónde guardar el resultado, cuándo saltar. El programador pensaba como la máquina. Los lenguajes modernos invirtieron la dirección: se escribe qué se quiere y el lenguaje se encarga del cómo.

Ese cambio parece filosófico hasta que se mide en horas de trabajo: el mismo cálculo que en C ocupa quince líneas y requiere un experto, en Python ocupa tres y lo lee cualquiera.

Un lenguaje moderno te deja escribir el problema; uno antiguo te obligaba a escribir la máquina.

Contar cuántas vigas de una lista superan su capacidad.

En C (simplificado, sin gestión de errores):

int contar_fallidas(Viga *vigas, int n, float *capacidades) {
int fallidas = 0;
for (int i = 0; i < n; i++) {
float momento = vigas[i].carga * vigas[i].luz * vigas[i].luz / 8.0f;
if (momento > capacidades[i]) {
fallidas += 1;
}
}
return fallidas;
}

Hay que decir el tipo de cada cosa, llevar el índice i, comprobar el límite y devolver un entero. Nada de eso es el problema; todo es el precio de hablar con la máquina.

En Python:

def contar_fallidas(vigas):
return sum(
1 for viga in vigas
if momento_maximo(viga.carga, viga.luz) > viga.capacidad
)

momento_maximo(carga, luz) se define en el capítulo 07; aquí importa el estilo, no la función. Los bloques de este capítulo son fragmentos para leer: todavía no hay que ejecutarlos.

Se lee: «cuenta uno por cada viga cuyo momento supere su capacidad». El índice no existe, no hay tipos que declarar —Python es de tipado dinámico: el tipo va con el valor, no con la variable— y sum sabe sumar.

«Declarativo» significa que describes el resultado, no los pasos. Pero alguien escribió los pasos dentro de sum, y por eso funciona.

Estilo Dices Ejemplo
Imperativo cómo, paso a paso for, while, acumuladores
Declarativo qué quieres sum(...), sorted(...), SQL
Mixto las dos cosas Python, casi siempre

SQL es el ejemplo puro: SELECT nombre FROM vigas WHERE momento > capacidad no dice cómo recorrer la tabla. HTML también: describes la página, no cómo pintarla.

En Python conviven los dos estilos, y saber cuál usar es parte del oficio. Otro fragmento para leer (supone que vigas y momento_maximo ya existen):

# imperativo: dice cómo
fallidas = []
for viga in vigas:
if momento_maximo(viga.carga, viga.luz) > viga.capacidad:
fallidas.append(viga)
# declarativo: dice qué
fallidas = [v for v in vigas if momento_maximo(v.carga, v.luz) > v.capacidad]

La segunda no es «más moderna» por moda: es más corta, no repite el nombre fallidas tres veces y expresa la intención en una línea.

Python se diseñó para que el código se pareciera a la frase que describe. Tres fragmentos sueltos (tampoco se ejecutan solos: vigas, viga y revisar vendrían de antes):

if viga.momento > viga.capacidad:
print("revisar")
for viga in vigas:
revisar(viga)
if not vigas:
print("no hay vigas")

if, for, in, not, is, and, or son palabras inglesas con el mismo significado. No es casualidad: Guido van Rossum eligió esa sintaxis para que leer código no requiriera traducirlo mentalmente a otro idioma.

Compáralo con el mismo control de flujo en ensamblador, donde un if son tres instrucciones y una etiqueta:

CMP AL, 0
JLE fin
...
fin:

Ahí no hay historia: hay máquina.

Reescribe este código imperativo en estilo declarativo, sin cambiar lo que hace. Las primeras líneas solo preparan los datos: SimpleNamespace es una forma rápida de crear un objeto con campos, para poder escribir viga.nombre; el capítulo 09 lo explica. Lo que hay que reescribir son las cuatro últimas.

from types import SimpleNamespace
vigas = [
SimpleNamespace(nombre="V-1", aprovechamiento=0.75),
SimpleNamespace(nombre="V-2", aprovechamiento=1.08),
]
nombres = []
for viga in vigas:
if viga.aprovechamiento < 1:
nombres.append(viga.nombre)
Solución
from types import SimpleNamespace
vigas = [
SimpleNamespace(nombre="V-1", aprovechamiento=0.75),
SimpleNamespace(nombre="V-2", aprovechamiento=1.08),
]
nombres = [viga.nombre for viga in vigas if viga.aprovechamiento < 1]
print(nombres) # ['V-1']

Una línea, mismo resultado. Lo que se gana: no hay una lista vacía que rellenar, ni un append que recordar, ni riesgo de olvidar el if dentro del bucle.

Lo que no cambia: sigue recorriendo todas las vigas y sigue creando una lista. El estilo declarativo es más corto, no más rápido.

Si lo que querías era solo contar, ni siquiera hace falta la lista:

total = sum(1 for v in vigas if v.aprovechamiento < 1)

Y ahí está la lección: el estilo se elige después de saber qué necesitas. La lista, si vas a recorrerla; el número, si solo vas a mostrarlo.

  • Ramalho, L. Fluent Python, 2ª ed., capítulo 1.
  • Lott, S. F. Modern Python Cookbook, 3ª ed., capítulo 9: programación funcional.