Programación funcional avanzada en Python

La programación funcional permite escribir código más expresivo, modular y seguro. En esta guía aprenderás técnicas avanzadas como funciones de orden superior, currying, composición, closures profundos y uso avanzado de map, filter y reduce.

1. Funciones de orden superior

Una función de orden superior recibe funciones como argumentos o devuelve funciones.

def aplicar(func, valor):
    return func(valor)

print(aplicar(lambda x: x * 3, 10))

2. Closures avanzados

Un closure captura variables del entorno externo y las mantiene vivas.

def multiplicador(n):
    def interno(x):
        return x * n
    return interno

por5 = multiplicador(5)
print(por5(10))

3. Currying

El currying transforma una función de varios argumentos en una cadena de funciones de un argumento.

def sumar(a):
    def interno(b):
        return a + b
    return interno

print(sumar(10)(5))

4. Composición de funciones

Componer funciones permite encadenar operaciones de forma declarativa.

def componer(f, g):
    return lambda x: f(g(x))

doble = lambda x: x * 2
incrementar = lambda x: x + 1

comp = componer(doble, incrementar)
print(comp(10))  # (10 + 1) * 2

5. map, filter y reduce en profundidad

from functools import reduce

nums = [1, 2, 3, 4, 5]

print(list(map(lambda x: x * 2, nums)))
print(list(filter(lambda x: x % 2 == 0, nums)))
print(reduce(lambda a, b: a + b, nums))

6. Funciones puras e inmutabilidad

Una función pura no modifica estado externo y siempre devuelve el mismo resultado para los mismos argumentos.

# Función pura
def pura(x):
    return x * 2

# Función impura
y = 10
def impura(x):
    return x + y

7. Ejercicios

def acumulador():
    total = 0
    def add(x):
        nonlocal total
        total += x
        return total
    return add

def curry3(a):
    return lambda b: lambda c: a + b + c

def comp3(a,b,c):
    return lambda x: a(b(c(x)))

reduce(lambda a,b: a*b, nums)

# Hacer pura: pasar y como argumento

8. Mini‑proyecto: Pipeline funcional

def pipeline(*funcs):
    def ejecutar(valor):
        for f in funcs:
            valor = f(valor)
        return valor
    return ejecutar

doble = lambda x: x * 2
incrementar = lambda x: x + 3
cuadrado = lambda x: x * x

p = pipeline(doble, incrementar, cuadrado)
print(p(5))

Siguiente guía