«FuncMage»: programación funcional en Python. Cinco ejercicios con
ambientación de magos que recorren lambdas, funciones de orden superior, closures,
functools y decoradores. Rank 02. Proyecto aún no hecho:
aquí se explica qué pide y qué enseña, sin solución.
ft_lstiter de Libft
o el qsort de la libc. En Python las funciones son ciudadanos de primera
clase: objetos como cualquier otro, que se guardan en variables, se meten en listas o
diccionarios, se pasan como argumento, se devuelven desde otra función y además se crean
en tiempo de ejecución, recordando el entorno donde nacieron. Sobre eso se apoya la
programación funcional. Sus raíces son antiguas: el cálculo lambda de Alonzo
Church (años 30) es el modelo matemático en el que todo es función, y de él toma nombre
la palabra clave lambda; Lisp (1958) llevó la idea a un lenguaje real, con
map, filter y reduce. Python adoptó parte de esa
herencia sin dejar de ser un lenguaje imperativo y orientado a objetos: en Python 3
reduce se movió de las funciones integradas al módulo
functools, los closures ganaron nonlocal (PEP 3104) y los
decoradores (PEP 318, Python 2.4) se convirtieron en una de las herramientas más usadas
del lenguaje, desde @staticmethod hasta los frameworks web. Este módulo no
usa librerías externas: todo sale de la biblioteca estándar.Cinco directorios, ex0/ a ex4/, con un fichero cada uno.
Las reglas comunes:
flake8. Cuando se use Callable como tipo, debe importarse de
collections.abc.typing, itertools, todas las
funciones integradas salvo eval() y exec(), los tipos estándar
con sus métodos y los módulos de la biblioteca estándar que hagan falta.
functools y operator solo donde el ejercicio los autorice.eval(),
exec() y las variables globales.Como adjunto viene un data_generator.py que genera datos de prueba (magos,
artefactos y hechizos) para usar en las implementaciones y durante la evaluación.
Cuatro funciones con firma dada, y todas las transformaciones con expresiones
lambda; nada de def para operaciones simples o de un solo
uso:
artifact_sorter(artifacts): ordena con sorted() y una
lambda una lista de artefactos ({'name', 'power', 'type'}) por
power, de mayor a menor.power_filter(mages, min_power): con filter() y una lambda,
devuelve en una lista los magos cuyo power es mayor o igual que
min_power.spell_transformer(spells): con map() y una lambda, rodea
cada nombre de hechizo con "* " y " *".mage_stats(mages): con lambdas en max() y
min(), devuelve un diccionario con max_power,
min_power y avg_power (la media, redondeada a 2
decimales).Para recordar la forma general, que no la del ejercicio: una lambda es una expresión
que produce una función sin nombre, y se pasa como key a funciones como
sorted:
>>> sorted(["kiwi", "fig", "banana"], key=lambda s: len(s))
['fig', 'kiwi', 'banana']
return): sirve para lo corto. El ejercicio
también enseña cómo trabajan sorted, min y max
con el parámetro key (comparan por lo que devuelve la función, pero
devuelven el elemento original) y que map y filter no devuelven
listas sino iteradores perezosos. El enunciado pregunta cuándo usar
lambda y cuándo una función normal.Todos los hechizos siguen el mismo contrato,
spell(target: str, power: int) -> str: reciben un objetivo y una potencia
y devuelven una frase con lo ocurrido. Hay que escribir cuatro funciones que reciben
hechizos y devuelven hechizos nuevos:
spell_combiner(spell1, spell2): una función que llama a los dos con los
mismos argumentos y devuelve una tupla con ambos resultados.power_amplifier(base_spell, multiplier): un hechizo con la misma firma
que multiplica la potencia antes de lanzar el original.conditional_caster(condition, spell): un hechizo que solo se lanza si
la condición es verdadera (condición y hechizo reciben los mismos argumentos); si no,
devuelve "Spell fizzled".spell_sequence(spells): una función que lanza todos los hechizos en
orden con los mismos argumentos y devuelve la lista de resultados.El programa debe demostrar el uso de todos estos modificadores.
Callable (de collections.abc; el de typing es un
alias obsoleto desde Python 3.9) y para qué sirve callable(), que comprueba
en tiempo de ejecución si un objeto se puede llamar.Cuatro fábricas de funciones que guardan estado sin variables globales:
mage_counter(): devuelve una función que cuenta cuántas veces se la ha
llamado y devuelve la cuenta (empezando en 1). Dos contadores distintos tienen estado
independiente.spell_accumulator(initial_power): devuelve una función que suma a un
total que parte de initial_power la cantidad recibida y devuelve el nuevo
total.enchantment_factory(enchantment_type): devuelve una función que recibe
un objeto y devuelve "enchantment_type item_name" (por ejemplo,
"Flaming Sword").memory_vault(): devuelve un diccionario con dos funciones,
'store' (guarda un par clave-valor) y 'recall' (devuelve el
valor o "Memory not found"), que comparten una memoria privada.static de C, pero una por
cada función creada y sin que nadie de fuera pueda tocarla. Con eso se consigue estado
privado sin clases ni globales. La pregunta del enunciado es la buena: por qué
global está prohibido y nonlocal permitido, y en qué se
diferencian (uno apunta al ámbito del módulo, compartido por todos; el otro, al ámbito de
la función que envuelve, propio de cada closure).spell_reducer(spells, operation): combina una lista de potencias con
functools.reduce y las funciones del módulo operator. Admite
"add", "multiply", "max" y "min";
con la lista vacía devuelve 0, y una operación desconocida debe tratarse como
error.partial_enchanter(base_enchantment): a partir de una función
(power: int, element: str, target: str) -> str, crea con
functools.partial tres versiones especializadas, todas con
power=50 y cada una con su elemento, y las devuelve en un
diccionario.memoized_fibonacci(n): el n-ésimo número de Fibonacci con el decorador
functools.lru_cache; la caché debe acelerar las llamadas repetidas, cosa
que se puede comprobar con cache_info().spell_dispatcher(): devuelve una función construida con
functools.singledispatch que se comporta según el tipo del argumento:
int (hechizo de daño), str (encantamiento) y
list (lanzamiento múltiple); la función base recibe Any y
maneja los tipos desconocidos.reduce pliega una
secuencia en un único valor aplicando una operación de dos en dos (la sacaron de las
funciones integradas en Python 3 porque un bucle suele leerse mejor, pero sigue en
functools). operator ofrece los operadores como funciones
(operator.add es +). partial fija algunos
argumentos y devuelve una función nueva con menos parámetros. lru_cache es
memoización: guardar resultados ya calculados, lo que convierte un Fibonacci
recursivo exponencial en lineal. Y singledispatch (PEP 443) son las
funciones genéricas: una implementación distinta según el tipo del primer argumento,
registrada aparte, en lugar de una cadena de isinstance.spell_timer(func): decorador que mide el tiempo de ejecución. Imprime
Casting nombre_de_la_función... antes y
Spell completed in X.XXX seconds (3 decimales) después, conserva los
metadatos con functools.wraps y devuelve el resultado original.power_validator(min_power): fábrica de decoradores con parámetro. Si la
potencia es suficiente (>= min_power) ejecuta la función; si no,
devuelve "Insufficient power for this spell". También con
wraps.retry_spell(max_attempts): si la función lanza una excepción, la
reintenta hasta max_attempts veces imprimiendo
Spell failed, retrying... (attempt n/max_attempts); si todos los intentos
fallan devuelve "Spell casting failed after max_attempts attempts", y si
alguno sale bien, su resultado.MageGuild: un método estático
validate_mage_name(name) (válido si tiene al menos 3 caracteres y solo
letras y espacios) y un método de instancia cast_spell(self, spell_name,
power) decorado con power_validator con
min_power=10, que devuelve
"Successfully cast spell_name with <power> power" o el mensaje de
potencia insuficiente.El enunciado sugiere time.sleep para simular hechizos que tardan.
Recordatorio de la sintaxis: la arroba es solo azúcar para reasignar el nombre.
@decorador
def f(): ...
# equivale a
def f(): ...
f = decorador(f)
@ la aplica al definirla. Sirve para
separar responsabilidades: medir tiempos, validar o reintentar sin ensuciar el código del
hechizo. Un decorador con parámetros, como power_validator(10), añade un
nivel más: es una función que devuelve el decorador. functools.wraps copia
el nombre, la docstring y demás metadatos de la original al envoltorio; sin él, la
función decorada pasa a llamarse como la interna. Y @staticmethod, que ya
salió en el Module 01, se ve ahora como lo que es: un decorador más, que hace que el
método no reciba self.map y filter no devuelven
listas; si la firma promete list, hay que convertir. Y un iterador se
agota al recorrerlo una vez.max()/min() sobre una secuencia vacía lanzan
ValueError. En ex3 el enunciado fija qué devolver con la lista vacía; en
ex0 hay que decidirlo.sorted devuelve una lista nueva y no
toca la original, a diferencia de list.sort().+= sobre un entero) la convierte en local y da
UnboundLocalError si no se declara nonlocal. Modificar un
objeto mutable de fuera, como un diccionario, no es reasignar.reduce sin valor inicial. Con una secuencia vacía lanza
TypeError. Y una operación desconocida no debe romper el programa sin
control.lru_cache en una función recursiva. Las llamadas recursivas
también pasan por la caché; cache_info() enseña aciertos y fallos.power_validator se aplica a una función suelta
y también a cast_spell, que recibe self antes que los demás
argumentos: el envoltorio tiene que funcionar en los dos casos.*args y **kwargs. Un envoltorio genérico no conoce
la firma de la función que decora; y las anotaciones de tipo siguen siendo
obligatorias también en él.global. Todo el estado vive en closures o en objetos,
y tampoco se permiten ficheros, eval ni exec.Enunciado «FuncMage — Master the Ancient Arts of Functional Programming», versión 3.2,
en packs/cursus/M2/212_Python_Module_10/ (en.subject.pdf y su
extracción subject.txt). El generador de datos adjunto está en
extra/generator.tar.gz.