Programación Funcional
Funciones puras, lambda, map, filter, reduce, enumerate y zip.
science
Funciones puras
En programación funcional, una función pura cumple dos condiciones:
- Mismo input → mismo output: dados los mismos argumentos, siempre retorna el mismo resultado
- Sin efectos secundarios (side effects): no modifica nada fuera de su propio scope
Un side effect es cualquier cosa que la función hace además de calcular y retornar su valor: imprimir, modificar variables globales, leer archivos, llamar a random(), etc.
python
# IMPURA: modifica variable externa (side effect)mi_lista = [1, 2, 3]def agregar_impura(numero): mi_lista.append(numero) # modifica estado externo # IMPURA: print es side effectdef aumentar_impura(x): print('retornando', x + 1) # side effect return x + 1 # IMPURA: random() no es deterministafrom random import randomdef escalar_random(x): return x * random() # PURA: solo depende de sus argumentosfrom copy import deepcopydef agregar_pura(lista, numero): copia = deepcopy(lista) # no toca la lista original copia.append(numero) return copiaLa pureza habilita caching con @cache: como el resultado siempre es el mismo para el mismo input, Python puede memorizar resultados y no recalcularlos. Esto no es posible con funciones impuras.
Tip
Cargando Quiz...
Cargando Quiz...
functions
Funciones lambda
Una función lambda es una función anónima definida en una sola línea:
lambda parámetros: expresión
- No necesita
return— la expresión ES el valor retornado - No puede contener statements (
for,while,if/elsecon cuerpo) — solo expresiones - Puede asignarse a una variable o usarse directamente como argumento (inline)
- Puede ser retornada desde otra función (closure)
python
# Equivalentes con def y lambdadef cuadrado(x): return x ** 2cuadrado_l = lambda x: x ** 2 print(cuadrado(5)) # 25print(cuadrado_l(5)) # 25 # Uso inline: sin asignar a variablenums = [3, 1, 4, 1, 5]print(sorted(nums, key=lambda x: -x)) # [5, 4, 3, 1, 1]tune
map y filter
Ambas reciben una función como primer argumento y retornan un iterador (no una lista directamente):
map(f, iterable) — aplica f a cada elemento. Equivale a (f(x) for x in iterable).
filter(f, iterable) — conserva solo los elementos donde f(x) es True. Equivale a (x for x in iterable if f(x)).
map(f, it1, it2) — aplica f a pares de elementos de ambos iterables. Para al más corto.
python
# map: transforma cada elementonombres = ['Ana', 'BUS', 'Carlos']minusculas = map(lambda s: s.lower(), nombres)print(list(minusculas)) # ['ana', 'bus', 'carlos'] # filter: conserva los que cumplen la condicionnums = [1, 2, 3, 4, 5, 6]pares = filter(lambda x: x % 2 == 0, nums)print(list(pares)) # [2, 4, 6]calculate
reduce
reduce de functools aplica una función binaria acumulativamente sobre un iterable, produciendo un único valor:
reduce(f, [a, b, c, d]) → f(f(f(a, b), c), d)
- Con inicializador:
reduce(f, iterable, val_inicial)— el valor inicial actúa como primer acumulado antes de la lista - Lista vacía sin inicializador →
TypeError - Lista con un solo elemento → retorna ese elemento sin aplicar
fnunca
python
from functools import reduce # Suma acumuladalista = [1, 2, 3, 4, 5]print(reduce(lambda x, y: x + y, lista)) # 15 # Concatenar con separadorpalabras = ['hola', 'mundo', 'python']print(reduce(lambda x, y: f'{x} | {y}', palabras)) # 'hola | mundo | python'data_object
enumerate y zip
Estas funciones trabajan con iterables sin necesitar una función como argumento:
enumerate(iterable) — genera tuplas (índice, elemento). Más pythónico que for i in range(len(lista)).
zip(it1, it2, ...) — empareja elementos en la misma posición de cada iterable. Para al iterable más corto.
zip(*pares) — desempaqueta/invierte la operación zip.
python
# enumerate: iterar con indicefrutas = ['manzana', 'pera', 'uva']for i, fruta in enumerate(frutas): print(f'{i}: {fruta}')# 0: manzana# 1: pera# 2: uva # zip: emparejar listas paralelasnombres = ['Ana', 'Luis', 'Maria']