La programación funcional en Python es un paradigma que trata de escribir el código utilizando funciones puras, inmutabilidad y evitando efectos secundarios. En este enfoque, las funciones son ciudadanos de primera clase (pueden ser asignadas a variables, pasadas como argumentos y devueltas por otras funciones). Se basa en principios matemáticos y es popular para realizar cálculos de manera clara, concisa y sin cambiar el estado.
La programación funcional es un estilo de programación que corresponde al paradigma de programación declarativo, no imperativo. En este paradigma, se dice cómo es el problema a resolver, en lugar de los pasos a seguir para resolverlo.
Entre otras características, la programación funcional nos aporta:
def suma(a, b):
return a + b # Siempre devuelve lo mismo para los mismos 'a' y 'b'
Inmutabilidad:
Funciones de orden superior:
def aplicar_funcion(func, valor):
return func(valor)
doble = lambda x: x * 2
print(aplicar_funcion(doble, 5)) # Salida: 10
map(): Aplica una función a cada elemento de una lista o secuencia.filter(): Filtra elementos de una lista que cumplen con una condición.reduce()(requiere importación de functools): Reduce una lista a un solo valor aplicando una función acumulativa.numeros = [1, 2, 3, 4]
dobles = list(map(lambda x: x * 2, numeros))
print(dobles) # Salida: [2, 4, 6, 8]
numeros = [1, 2, 3, 4, 5]
pares = list(filter(lambda x: x % 2 == 0, numeros))
print(pares) # Salida: [2, 4]
from functools import reduce
suma = reduce(lambda x, y: x + y, [1, 2, 3, 4])
print(suma) # Salida: 10
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)
print(factorial(5)) # Salida: 120
def crear_multiplicador(n):
return lambda x: x * n
doble = crear_multiplicador(2)
print(doble(5)) # Salida: 10
def contador():
n = 0
while True:
yield n
n += 1
generador = contador()
print(next(generador)) # Salida: 0
print(next(generador)) # Salida: 1
Las funciones lambda en Python son funciones anónimas (es decir, funciones que no tienen un nombre) y se utilizan principalmente para operaciones simples y rápidas. Estas funciones se definen usando la palabra clave lambda, seguida de los parámetros de entrada, dos puntos, y luego la expresión que se va a evaluar. A diferencia de las funciones definidas con def, una función lambda es siempre una única expresión, lo que las hace ideales para usar en situaciones en las que se requiere una función pequeña y de una sola línea.
lambda argumentos: expresión
Argumentos: Los parámetros que la función recibe (pueden ser múltiples o ninguno).
Expresión: La operación que realizará la función y cuyo resultado se devolverá automáticamente.
Características clave:
suma = lambda a, b: a + b
print(suma(3, 4)) # Output: 7
numeros = [1, 2, 3, 4, 5]
cuadrados = list(map(lambda x: x ** 2, numeros))
print(cuadrados) # Output: [1, 4, 9, 16, 25]
numeros = [1, 2, 3, 4, 5, 6, 7, 8]
pares = list(filter(lambda x: x % 2 == 0, numeros))
print(pares) # Output: [2, 4, 6, 8]
Ordenar con sorted() y una función lambda: Se puede utilizar una función lambda para personalizar cómo se ordena una lista de tuplas.
lista = [(1, 'banana'), (2, 'apple'), (3, 'orange')]
lista_ordenada = sorted(lista, key=lambda x: x[1])
print(lista_ordenada) # Output: [(2, 'apple'), (1, 'banana'), (3, 'orange')]
Si comparamos una función lambda con una función definida con def, esta última puede tener múltiples líneas y lógica compleja, mientras que una lambda se usa para casos más simples. Ejemplo de una función normal:
def suma(a, b):
return a + b
Este código es equivalente a la función lambda:
suma = lambda x, y: x + y
print(suma(3, 5)) # Salida: 8
Brevedad: Las lambdas son compactas y permiten una definición rápida de funciones sencillas.
Usadas en funciones de orden superior: Son ideales para usar en combinaciones con funciones como map, filter, y sorted.
Legibilidad: Si se usan de manera excesiva o para operaciones complejas, pueden dificultar la legibilidad del código.
Falta de reutilización: No se pueden reutilizar fácilmente, ya que no están asociadas a un nombre.
En resumen, las funciones lambda son útiles para definir rápidamente funciones cortas y sencillas que pueden pasarse como argumentos a otras funciones o utilizarse directamente en expresiones cortas.