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.
En una línea
Sección titulada «En una línea»Un lenguaje moderno te deja escribir el problema; uno antiguo te obligaba a escribir la máquina.
La misma tarea, dos idiomas
Sección titulada «La misma tarea, dos idiomas»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 no es magia
Sección titulada «Declarativo no es magia»«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ómofallidas = []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.
Por qué se lee como inglés
Sección titulada «Por qué se lee como inglés»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, 0JLE fin...fin:Ahí no hay historia: hay máquina.
La trampa
Sección titulada «La trampa»Ejercicio
Sección titulada «Ejercicio»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.
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed., capítulo 1.
- Lott, S. F. Modern Python Cookbook, 3ª ed., capítulo 9: programación funcional.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 02 · Contar una historia: el porqué de los nombres y del orden.
- 06 · Decisiones y repeticiones: el imperativo, cuando hace falta.
- 07 · Funciones: el siguiente nivel de «dar nombre a un paso».