Funciones Lambda y Programación Funcional en Python

# Funciones de orden superior: # Son aquellas que **reciben como parámetro otra función.** Las más importantes de python son: ## map() * Aplica una función a cada elemento de un iterable. ## filter() * Filtra cada elemento de un iterable travez de una función. ## reduce() 1. Toma los dos primeros elementos de un iterable y aplica un función. 2. Toma el resutado anterior y el elemento siguiente y aplica la funcion. 3. Repite hasta acabar con todos los elementos del iterable. ... Estas funciones retornar un elemento **iterador**, por eso es necesario usar la funcion `list()` para convertirlo en un elemento **iterable**.

Las \*\*funciones lambda\*\* y la \*\*programación funcional\*\* en Python son conceptos poderosos que permiten escribir código más conciso, flexible y expresivo. Vamos a explorarlos en detalle. \### Funciones Lambda Una \*\*función lambda\*\* en Python es una función anónima, es decir, una función que no tiene nombre y se define en una sola línea usando la palabra clave `lambda`. Estas funciones son útiles para operaciones simples y cortas que se pueden definir rápidamente sin la necesidad de una función formal. \#### Sintaxis de una Función Lambda ```python lambda argumentos: expresión ``` \- \*\*`argumentos`\*\*: Son los parámetros que la función tomará. \- \*\*`expresión`\*\*: Es una única expresión que se evalúa y devuelve como resultado de la función. \#### Ejemplo Simple ```python \# Función lambda que suma dos números suma = lambda x, y: x + y \# Usar la función lambda resultado = suma(3, 5) print(resultado) # Salida: 8 ``` En este ejemplo, `suma` es una función lambda que toma dos argumentos, `x` y `y`, y devuelve su suma. \### Uso de Funciones Lambda con Funciones Integradas Las funciones lambda son comúnmente usadas junto con funciones integradas como `map()`, `filter()`, y `sorted()`. \#### `map()` `map()` aplica una función a todos los elementos de una secuencia. ```python numeros = \[1, 2, 3, 4] cuadrados = list(map(lambda x: x \*\* 2, numeros)) print(cuadrados) # Salida: \[1, 4, 9, 16] ``` Aquí, `map()` aplica la función lambda a cada elemento de la lista `numeros`, devolviendo una nueva lista con los resultados. \#### `filter()` `filter()` filtra los elementos de una secuencia según una función que devuelve `True` o `False`. ```python numeros = \[1, 2, 3, 4, 5, 6] pares = list(filter(lambda x: x % 2 == 0, numeros)) print(pares) # Salida: \[2, 4, 6] ``` En este ejemplo, `filter()` utiliza la función lambda para seleccionar solo los números pares de la lista. \#### `sorted()` `sorted()` ordena los elementos de una secuencia. Puedes usar una función lambda para definir la clave de ordenamiento. ```python puntos = \[(1, 2), (3, 1), (5, 4), (2, 0)] ordenado\_por\_y = sorted(puntos, key=lambda punto: punto\[1]) print(ordenado\_por\_y) # Salida: \[(2, 0), (3, 1), (1, 2), (5, 4)] ``` En este caso, `sorted()` ordena la lista de tuplas según el segundo elemento de cada tupla. \### Programación Funcional en Python La \*\*programación funcional\*\* es un paradigma de programación que trata a las funciones como ciudadanos de primera clase, lo que significa que pueden ser pasadas como argumentos, retornadas desde otras funciones y asignadas a variables. \#### Principios Clave: 1\. \*\*Funciones como Primeras Clases\*\*: Las funciones pueden ser asignadas a variables, almacenadas en estructuras de datos, y pasadas como argumentos. 2\. \*\*Inmutabilidad\*\*: Prefiere el uso de datos inmutables, lo que significa que las estructuras de datos no se modifican después de su creación. 3\. \*\*Funciones Puras\*\*: Una función pura es aquella que, dado el mismo conjunto de argumentos, siempre devuelve el mismo resultado y no tiene efectos secundarios. \#### Funciones de Orden Superior Una función de orden superior es una función que toma una o más funciones como argumentos, o devuelve una función como resultado. \##### Ejemplo: Función de Orden Superior ```python def aplicar\_operacion(operacion, x, y): return operacion(x, y) suma = lambda x, y: x + y resultado = aplicar\_operacion(suma, 5, 3) print(resultado) # Salida: 8 ``` En este ejemplo, `aplicar\_operacion` es una función de orden superior que recibe otra función `operacion` y dos números, aplicando `operacion` a estos números. \#### Composición de Funciones La composición de funciones implica combinar funciones pequeñas para crear una función más compleja. ```python def doble(x): return x \* 2 def incrementar(x): return x + 1 def compuesto(f, g, x): return f(g(x)) resultado = compuesto(doble, incrementar, 3) print(resultado) # Salida: 8 ``` Aquí, `compuesto` toma dos funciones (`f` y `g`) y un valor `x`, y aplica `g` a `x`, luego aplica `f` al resultado de `g(x)`. \### Funciones Integradas para Programación Funcional \- \*\*`map(función, iterable)`\*\*: Aplica `función` a cada elemento de `iterable`. \- \*\*`filter(función, iterable)`\*\*: Filtra `iterable` dejando solo los elementos donde `función` devuelva `True`. \- \*\*`reduce(función, iterable)`\*\*: Acumula los elementos de `iterable` aplicando `función` secuencialmente (requiere importar desde `functools`). \#### Ejemplo: `reduce()` ```python from functools import reduce numeros = \[1, 2, 3, 4] producto = reduce(lambda x, y: x \* y, numeros) print(producto) # Salida: 24 ``` Aquí, `reduce()` multiplica todos los números de la lista `numeros`. \### Ventajas y Consideraciones \- \*\*Ventajas\*\*: \- Código más conciso y expresivo. \- Facilita la creación de funciones reutilizables y composables. \- Fomenta la inmutabilidad y la transparencia referencial. \- \*\*Consideraciones\*\*: \- El abuso de funciones lambda puede hacer que el código sea difícil de leer. \- La programación funcional puede ser menos intuitiva para principiantes en comparación con paradigmas más imperativos. \### Conclusión Las funciones lambda y la programación funcional en Python ofrecen herramientas potentes para escribir código más modular, limpio y expresivo. Si bien no siempre es necesario adoptar la programación funcional en su totalidad, comprender estos conceptos y utilizarlos cuando sean apropiados puede mejorar la eficiencia y legibilidad de tu código.

#### Funciones Lambda Las funciones lambda, también conocidas como funciones anónimas, son pequeñas funciones de una sola línea que se definen usando la palabra clave `lambda`. No requieren un nombre explícito y se utilizan para realizar operaciones simples. La sintaxis de una función lambda ### Obtener los Números Impares de un Rango Vamos a utilizar la función `filter` junto con una función lambda para obtener los números impares de un rango. ```js numbers = range(101) print('#'*100) #pares de cada numero impar_numbers = list(filter(lambda x: x%2 != 0, numbers)) print('impares: ', impar_numbers) ```

**Map:** * \# tranformaciones a una lista dada de elementos (como una lista, tupla o conjunto) * \# genera un nuevo iterable que contiene los resultados de aplicar esa función a cada elemento * \# correspondiente del iterable original. * \# map(func, iterable) ```python def cocinar(ingrediente): if ingrediente == '🐔': return '🍗' elif ingrediente == '🐮': return '🍔' elif ingrediente == '🥔': return '🍟' else: return '🍪' # ejecución ingredientes = ['🐔', '🐮', '🥔'] resultado = map(cocinar, ingredientes) lista_r = list(resultado) print(lista_r) # con lambda ingredientes = ['🐔', '⚽', '🥔'] cocinar_v2 = lambda ingrediente: '🍗' if ingrediente == '🐔' else ('🍔' if ingrediente == '🐮' else ('🍟' if ingrediente == '🥔' else '🍪')) resultado = map(cocinar_v2, ingredientes) lista_r = list(resultado) print(lista_r) ```

Les comparto un ejercicio adicional que use para reforzar el tema. Tienes una lista de palabras. Crea una nueva lista que contenga solo las palabras que comienzan con una vocal (a, e, i, o, u). `palabras = ['manzana', 'banana', 'cereza', 'uva', 'pera']palab = list(filter(lambda x:x[0] in ('a','e','i','o','u'),palabras))print(palab)`

## Funciones Lambda y Programación Funcional en Python Las funciones lambda en Python son funciones anónimas, es decir, que no tienen nombre y se definen en una sola línea. Se usan cuando necesitas una función sencilla temporalmente. Se escriben con la palabra clave `lambda`, seguida de los argumentos y la expresión a ejecutar. La programación funcional se enfoca en aplicar funciones a datos, y en Python usamos herramientas como `map`, `filter` y las lambdas. * `map(función, iterable)`: Aplica una función a cada elemento de un iterable (como una lista) y devuelve un nuevo iterable con los resultados. Se usa cuando quieres transformar todos los elementos de una lista, por ejemplo, convertir una lista de números en sus cuadrados. EJEMPLO: map(lambda x: x\*\*2, \[1, 2, 3]) # \[1, 4, 9] * `filter(función, iterable)`: Filtra los elementos de un iterable según si cumplen o no con una condición, devolviendo solo los elementos que cumplen. EJEMPLO: filter(lambda x: x > 2, \[1, 2, 3, 4]) # \[3, 4]

Lambda permite crear una función anónima que hace lo mismo que una función, pero con menos líneas código. Las expresiones lambda también se conocen como funciones anónimas. Filter consiste en tomar sólo los elementos de la lista que cumplan cierta condición.

Considero que estos los usos más habituales de una función lambda son implementandolas en: * map() * filter() * reduce(), en el caso de este hay que importar functools Les dejo un ejemplo de la aplicación de lambda en cada uno ```python from functools import reduce add = lambda a,b : a + b print(add(1,2)) #Lista Original numbers = list(range(10)) print(numbers) #Cuadrado de cada numero squard_numbers = list(map(lambda n: n**2, numbers)) print(squard_numbers) #Pares pars_numbers = list(filter(lambda n: n%2 ==0, squard_numbers)) print(pars_numbers) #Suma de todos acum_numbers = reduce(lambda total, n: total + n, pars_numbers) print(acum_numbers) ```

lambda es muy parecida a (arrow functions)=> on js pero respetan el LEGB que es el acronimo que define las reglas de contexto y no capturan el contexto al rededor como las arrow function lo hacen.

```js #Resumiendo la calculadora de la clase anterior dict = { "1": { "name": "Suma", "function": lambda x, y: x + y }, "2": { "name": "Resta", "function": lambda x, y: x - y }, "3": { "name": "Multiplicación", "function": lambda x, y: x * y }, "4": { "name": "División", "function": lambda x, y: x / y } } print('Seleccione una operación:') for key in dict: print(f'{key}. {dict[key]["name"]}') selected = input() if selected not in dict: print('Operación inválida') exit() print('Inserta el primer valor') val1 = int(input()) print('Inserta el segundo valor') val2 = int(input()) print(dict[selected]["function"](val1, val2)) ```

Mi aporte def calcular\_operacion(a, b, op): operaciones = { "1": a + b, "2": a - b, "3": a \* b, "4": a / b if b != 0 else "Error: No se puede dividir entre cero." } resultado = operaciones.get(op, "Opción no válida") print(f"Resultado: {int(resultado) if isinstance(resultado, float) and resultado.is\_integer() else resultado}") def calculator(): while True: print("\n1. Suma\n2. Resta\n3. Multiplicación\n4. División\n5. Salir") op = input("Seleccione operación (1-5): ") if op == "5": break if op in \["1", "2", "3", "4"]: a, b = float(input("Primer número: ")), float(input("Segundo número: ")) calcular\_operacion(a, b, op) else: print("Opción no válida.") calculator()


Repasando : numbers = range(11) cuadrado = map(lambda x: x\*\*2 , numbers) print(list(cuadrado))

Yo aprendí primero JS, las funciones Lambda son el equivalente a las funciones de flecha de JS () =>

explicame el uso de map en python como para un niño de 10 años ###### ChatGPT dijo: ChatGPT Explicacion de chat gpt uso de map. 😊 Imagina que tienes una lista de juguetes y quieres pintarlos de un color diferente, digamos, de azul. En lugar de pintar cada juguete uno por uno, tienes un pincel mágico llamado `map()` que puede pintar todos los juguetes de la lista de una sola vez.

autor chatgpt: explicame el uso de filter en python como para un niño de 10 años ###### ChatGPT dijo: ¡Por supuesto! Imagina que tienes una caja llena de tus juguetes. Pero hoy, solo quieres jugar con los juguetes de color rojo. Así que decides mirar cada juguete y, si es rojo, lo colocas en una nueva caja de "juguetes rojos". En programación con Python, la función `filter()` hace algo muy parecido. `filter()` te ayuda a **filtrar elementos de una lista** que cumplen una cierta condición y te devuelve solo esos elementos que pasaron la "prueba".

Estaría buenísimo que se pudiera ver más aplicación de los conceptos (en algo práctico de la vida real), ayudaría muchísimo!

Les dejo un codigo incluyendo los numero primos porque ajá: ```python #Cuadrado de cada numero numbers = range(0, 11) squared_numbers = list(map(lambda a: a ** 2, numbers)) print("Cuadrado es: ", squared_numbers) #Pares even_numbers = list(filter(lambda a: a % 2 == 0, numbers)) print("Pares: ", even_numbers) #Impares odd_numbers = list(filter(lambda a: a % 2 != 0, numbers)) print("Impares: ", odd_numbers) #primos def is_prime(number): if number < 2: return False for i in range(2, number): if number % i == 0: return False return True print("Primos: ", list(filter(is_prime, numbers))) ```

Hola! Les comparto ejemplos haciendo uso de la función `reduce`la cual reduce los valores de un array a un único valor. La función reduce funciona de la siguiente manera: Se llama a la función binaria en los dos primeros elementos de la secuencia. Luego, se llama a la función en el resultado y el siguiente elemento. Se repite el proceso hasta reducir los elementos de la secuencia a un solo valor. ```python from functools import reduce numbers = range(11) # Suma todos los valores de la lista sum_of_numbers = reduce(lambda x, y: x + y, numbers) print("La suma de los números es:", sum_of_numbers) # Suma de todos los numeros impares de la lista sum_of_add_numbers = reduce(lambda x, y: x + y, filter(lambda x: x % 2 != 0, numbers)) print("La suma de los números impares es:", sum_of_add_numbers) ```

el ejercicio anterior pero con lambda: ```python add = lambda a,b: a+b subtract = lambda a,b: a-b multiply = lambda a,b: a*b divide = lambda a,b: a/b def calculator(): while True: print('Selecione una opcion') print('1. Suma') print('2. Resta') print('3. Multiplicacion') print('4. Division') print('5. Salir') option = input('\nElija una opcion 1, 2, 3, 4, 5:') if option == '5': print('Saliste de la calculadora') break elif option in ['1','2','3','4']: num1 = float(input('Ingrese el primer valor:')) num2 = float(input('Ingrese el segundo valor:')) if option == '1': print('La suma es: ', add(num1,num2)) if option == '2': print('La resta es :', subtract(num1,num2)) if option == '3': print('La multiplicacion es :', multiply(num1,num2)) if option == '4': print('La division es :', divide(num1,num2)) else: print('Opcion invalida intente nuevamente') calculator() ```

Me gustaria que se hable por lo menos brevemente sobre las funciones map() y filter(). Para añadir: La funcion map() para espera una funcion ya sea declarada en otra parte del codigo como argumento y ademas espera una lista. En el argumento de la funcion `map()`, tambien, se puede añadir un lambda, como en este video. En el caso del filter() espera tambien una funcion, pero , que esta retorne TRUE o FALSE luego de analizar cada elemento con una condicional. Por ello es que en la funcion lambda del video hace una comparación. ¿x%2 == 0 ? si es true devuelve el elemento para que sea añadido a la nueva lista.

Cuando estamos trabajando con listas y queremos aplicar una función a cada uno de estos elementos, podemos utilizar map acompañado de Lambda ```js numbers = range(11) squared_numbers = list(map(lambda x: x**2, numbers)) print("Cuadrados", squeared_numbers) ```Funciones de orden superior: ## Son aquellas que **reciben como parámetro otra función.** Las más importantes de python son: ### map() * Aplica una función a cada elemento de un iterable. ### filter() * Filtra cada elemento de un iterable travez de una función. ### reduce()

```python """ def func(args): return val # lambda func = lambda args: val """ full_name = lambda name, last_name: f'Full name is {name.title()} {last_name.title()}' text = full_name('ronaldo', 'jiménez acosta') print(text) ```

Aquí falló el markdown por una letra intrusa jaja


Aunque lambda también se puede usar dentro la palabra reservada def, de todas formas, lambda ahorra líneas de código sin perder la eficiencia del código. Buena clase.

Estoy sorprendido gratamente en la manera como Python facilita la gramatica de la programacion , me parece sencilla , mas practica , cada vez me entusiasma mas

esto es parecido a: list comprehension

Apuntes, codigo y ejercicios. ```python # FUNCIONES LAMBDA Y PROGRAMACION FUNCIONAL EN PYTHON # lambda no cupa declar funciones # es una forma de hacer funcones anonimas # Se utliza para funcon3es sencillas, lambda solo requeire parametros y la operacion requerida variableL = lambda a, b: a + b # al utilizar lambda le estoy diciendo que variable existe y como se realizara la operacion print(variableL(10,4)) #Al llamar a la variable que tiene la funcion lambda las declaro como estan acomodadas y le asignara los valores #Al imprimirlo me mostrara ya directamente el resultado tresvar = lambda a, b, c: a * b * c print(tresvar(80,5,2)) #Cuadrado de cada numero numbers = range(11) # Recordemos que range genera numeros y no especificamos inicio va de 0 al 11, en variable numbers squared_numbers = list(map(lambda x: x**2, numbers)) # "map" sirve para alacenar los datos de x en memoria pero no pueden ser accesado directamnte solo almacenados #vermap = map(lambda x: x**2, numbers) # por eso que ocupamos "list", "list" va por ellos ala memria y los va sacando en forma de lista para leerlos #print(vermap) # asi es como se veria si lo immprimo "<map object at 0x0000023E6E9F21D0>" print("Cuadrados:", squared_numbers ) # se almacenana en la variable y esta ya puede ser leida #Pares even_numbers = list(filter(lambda x: x%2 == 0, numbers)) # con "filter" podemos seleccionar los elementos si cumplen cierta funcion #verfiltro= filter(lambda x: x%2 == 0, numbers) # con ambda le decimos que para x siempre que dividamos entre 2 y que el RESTO sea 0 #print(verfiltro) # se ve asi <filter object at 0x0000023E5C8EE6E0> , podemos ver que solo se guarda en memoria pero no puede ser accedido asi es por eso que tmbn neceitamos "list" print("Pares:", even_numbers) ```# FUNCIONES LAMBDA Y PROGRAMACION FUNCIONAL EN PYTHON# lambda no cupa declar funciones# es una forma de hacer funcones anonimas # Se utliza para funcon3es sencillas, lambda solo requeire parametros y la operacion requerida variableL  = lambda a, b: a + b    # al utilizar lambda le estoy diciendo que variable existe y como se realizara la operacion print(variableL(10,4))             #Al llamar a la variable que tiene la funcion lambda las declaro como estan acomodadas y le asignara los valores                            #Al imprimirlo me mostrara ya directamente el resultadotresvar = lambda a, b, c: a \* b \* cprint(tresvar(80,5,2)) \#Cuadrado de cada numeronumbers = range(11)         # Recordemos que range genera numeros y no especificamos inicio va de 0 al 11, en variable numberssquared\_numbers = list(map(lambda x: x\*\*2, numbers))  # "map" sirve para alacenar los datos de x  en memoria pero no pueden ser accesado directamnte solo almacenados #vermap = map(lambda x: x\*\*2, numbers)                # por eso que ocupamos "list", "list" va por ellos ala memria y los va sacando en forma de lista para leerlos#print(vermap) # asi es como se veria si lo immprimo "\<map object at 0x0000023E6E9F21D0>"print("Cuadrados:", squared\_numbers ) # se almacenana en la variable y esta ya puede ser leida \#Pareseven\_numbers = list(filter(lambda x: x%2 == 0, numbers)) # con "filter" podemos seleccionar los elementos si cumplen cierta funcion#verfiltro= filter(lambda x: x%2 == 0, numbers) # con ambda le decimos que para x siempre que dividamos entre 2 y que el RESTO sea 0#print(verfiltro) # se ve asi \<filter object at 0x0000023E5C8EE6E0> , podemos ver que solo se guarda en memoria pero no puede ser accedido asi es por eso que tmbn neceitamos "list"print("Pares:", even\_numbers)

Les dejo un poco de información de map, cortesía de Ada, y algo que logré hacer: "El término "map" en el contexto de la función `map()` en Python se refiere a la operación de mapeo o transformación que se realiza sobre cada elemento de un iterable. En programación, el mapeo se refiere a la idea de aplicar una función a cada elemento de una colección o secuencia de datos para obtener una nueva colección o secuencia con los resultados de esa función aplicada a cada elemento. En el caso de la función `map()` en Python, se utiliza para mapear o transformar cada elemento de un iterable utilizando una función especificada como argumento. La función `map()` toma dos argumentos: la función a aplicar y el iterable sobre el cual se va a aplicar esa función. La función `map()` recorre cada elemento del iterable y aplica la función especificada a cada uno de ellos, generando un nuevo iterable con los resultados de esa transformación." Pueden imprimir lo que genera map() con un ciclo for:  Pueden ver el código fuente aquí: <https://codeberg.org/Unsubtly7897/python-platzi/src/branch/main/mapped_numbers.py> Pueden generar imágenes con código fuente aquí: <https://carbon.now.sh/>


Una lista de numeros pares en una sola linea de codigo: ```js print (list(filter(lambda x: x%2 == 0, range(1000)))) ```.

```python add = lambda a, b: a+b print(add(10,4)) multiply = lambda a, b: a*b print(multiply(80,5)) #Cuadrado de cada número numbers = range(11) squared_numbers = list(map(lambda x: x**2, numbers)) print("Cuadrado: ", squared_numbers) #Pares even_numbers = list(filter(lambda x: x%2 == 0, numbers)) print("Pares: ", even_numbers) ```add = lambda a, b: a+bprint(add(10,4)) multiply = lambda a, b: a\*bprint(multiply(80,5)) \#Cuadrado de cada númeronumbers = range(11)squared\_numbers = list(map(lambda x: x\*\*2, numbers)) print("Cuadrado: ", squared\_numbers) \#Pareseven\_numbers = list(filter(lambda x: x%2 == 0, numbers))print("Pares: ", even\_numbers)