Higher order function: una función dentro de otra función

Normalmente solemos usar parámetros y argumentos como sinónimos, y en la práctica podemos inferir lo que esto significa según el contexto. Pero en un entorno profesional, deberíamos tener muy claro que los parámetro son las reglas o instrucciones que definimos dentro de la función, mientras los argumentos son los datos que le pasamos a la función para que los “reemplace” y ejecute la función.

Algo así como en matemáticas básicas, cuando definimos y = x^2 + x + 3, la derecha de la ecuación serían los parámetros, mientras que los argumentos, serían los valores que le asignamos a la x, bien sea para encontrar las coordenadas de un punto (una iteración), o para trazar la gráfica completa (multiples iteraciones)…

**Parámetros: **Reglas Internas de la Función.

**Argumentos: **Datos Externos que le Pasamos a la Función para que Pueda Hacer sus Cálculos.

^_^

Amigos les comparto mi experiencia hasta ahora:
Cuando comenzaron las explicaciones sobre funciones realmente batallé bastante, comencé a pensar que tal vez esto no es lo mio, que es muy complicado, y decidí por mera curiosidad regresar a ver desde el inicio el curso de fundamentos de Python para toparme con que entendí la mayoría de las cosas a la perfección y ya sabía muchas cosas que la primera vez no me quedaron claras, hoy se cosas que hace un mes no sabía y la mejor forma de conocer tu avance es comparandose con uno mismo, a veces los aportes pueden intimidar un poco porque uno asume que los demás compañeros entendieron todo a la primera y uno no, ustedes no se desanimen, sigan con el curso y vuelvanlo a ver en un par de meses para que vean su avance, hasta aqui mi reporte joaquin :v

Higher order function: una función dentro de otra función
Una función de Orden Superior o en sus siglas HOF se le lama así solo cuando contiene otras funciones como parámetro de entrada o devuelve una función como salida, es decir que en este caso las funciones que operan a otras funciones se les denomina Higher order function.

También hay que entender que a estas Funciones de Orden Superior HOF se aplican para funciones y métodos que toman como funciones a los parámetros o devuelven una función como un resultado.

Propiedades de HOF

• Una función es una instancia de tipo objeto.
• Puede almacenar una función en una variable.
• Puede pasar una función como un parámetro a otra función.
• Puede devolver la función desde una función.
• Se puede almacenar en una estructura de datos como tablas, listas, etc.

def increment(x):
  return x + 10

increment_v2 = lambda x: x + 10

def hof(x, func):
  return x + func(x)

hof_v2 = lambda x, func: x + func(x) + func(x)

result = hof(20, increment)
# 20 + (20 + 10)
print(result)

En este caso Observamos como utilizando la función lambda podemos continuar seguir la función.

_Produccion_
50

Ahora HOF podemos incluir en este caso un signo de operación matemático de suma y multiplicación.

def increment(x):
  return x + 10

increment_v2 = lambda x: x + 10

def hof(x, func):
  return x + func(x)

hof_v2 = lambda x, func: x + func(x) + func(x)

result = hof(20, increment)
# 20 + (20 + 10)
print(result)

result = hof_v2(20, increment_v2)
print(result)

result = hof_v2(20, lambda x: x + 2)
result = hof_v2(20, lambda x: x * 2)

_Producción:_
50
80

Material de apoyo

Interesante pero, con cuidadito no… que despúes hacemos código poco legible y eso no esta bueno para un equipo de trabajo.
Es importante conocer las herramientas, pero no usarlas todas al mismo tiempo sin justificación.
El profe muy bien explica “todo lo que es posible”, pero ya la experiencia nos dará el criterio para elegir que usar y que no.
Recordemos que posiblemente tu código necesite mantenimiento y es importante que al volver entendamos como estan atados los hilos.
Acá es muy fácil pasarse la mano y romper varios principios del zen de python.

No sabía que Python podía recibir funciones en los parámetros de otras funciones, parecido a lo que se hace con los “callbacks” en JavaScript.

La versión más super resumida que logré

(lambda x, func: x + func(x))(2, lambda x: x + 1)

Mis notas de la clase:

def increment(x):
  return x +1 

def high_ord_func(x, func):
  return x + func(x)


result = high_ord_func(2, increment)
print(result)

# Utilizando lambda en ambas funciones
increment_v2 = lambda x: x+1
high_ord_func_v2 = lambda x, func: x + func(x)

result = high_ord_func_v2(2, increment_v2)
print(result)

#Lambda directo en la funcion
result = high_ord_func_v2(2, lambda x: x+2)
print(result)

Echo en falta el uso de elementos de aprendizaje más conceptuales y teóricos como diagramas de flujo, dibujos y uso de metáforas explicativas que hagan más ameno y visual la explicación. ¿Para qué quiero tanto código si no entiendo el concepto en sí o el caso de uso de dicha función?

Este profe solo fue bueno para el primer curso, en este explica muy mal

Yo hice una calculadora con lambdas:

def calculadora(a, b, func):
  return func(a, b)
  
suma = lambda a, b: a + b
resta = lambda a, b: a - b
multiplicacion = lambda a, b: a * b
division = lambda a, b: a / b
potenciacion = lambda a, b: a ** b

operacion = calculadora(3, 2, potenciacion)
print(operacion)

que les parece

Es un poco complicado al inicio pero con el tiempo lo comprenderemos mejor, lo bueno es saber que esto existe para que un futuro podamos leerlo y si tenemos dudas podemos profundizar en el tema si asi lo requerimos.

aprendiendo mucho en poco tiempo , genial

Un resumen…

• Entonces una “high order function” es una función que puede tomar una o más funciones como argumentos y/o devolver una función como resultado.
• Esto significa que las “high order functions” permiten que otras funciones se comporten como datos y se manipulen de manera flexible y dinámica dentro del programa.
  - En resumen, son funciones que trabajan con otras funciones.

por que hacerlo sobre el mismo ejemplo? no puede crear uno nuevo y que se vea mas limpio?

nooo no entiendoooo

Les traigo un pequeño programita que hice.

"""
Tema: High Order
Filtrar números pares: Escribe una función que tome una lista de números como entrada y use una Higher Order Function para filtrar y devolver una nueva lista que contenga solo los números pares.
"""

def es_par(numero):
    return numero % 2 == 0

def filter_pares(funcion_validacion, lista):
    return [numero for numero in lista if funcion_validacion(numero)]

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

numeros_pares = filter_pares(es_par, numeros)
print("Números pares:", numeros_pares)

Esta es otra explicación aparte de la que hizo Stephen Hawking en Los Padrinos Magicos de porque 2 + 2 es 5

Otra maravilla las lambda funcions:

def increment(x):
  return x + 1

increment_v2 = lambda x : x + 1

def hof(x, func):
  return x + func(x)

hof_v2 = lambda x, func : x + func(x)

result = hof(2, increment)

print(result)

re_result = hof(2,increment_v2)

print(re_result)

re_result_v2 = hof(2,lambda x : x + 1)
re_result_v3 = hof(2,lambda x : x * 5)
re_result_v4 = hof(2,lambda x : x * 7)
print(re_result_v2)
print(re_result_v3)
print(re_result_v4)

Me recuerda a las funciones de callback de JS. Se me ocurre para casos de uso donde debamos tener un cierto dinamismo en base a un contexto determinado, donde primero hacemos algo con el primer parametro y luego ejecutamos la funcion recibida que puede variar segun el contexto de la aplicacion y evitamos sobrecargar de logica a esta funcion, simplemente esta ejecutara lo que debe hacer con el primer parametro y luego procedera a ejecutar la recibida en el segundo parametro, casi como una cola de tareas tambien podria verse o incluso un arbol de tareas.

#HOF are functions that either:
#accept a function as an argument or
# returns a function
#this is allowed in python because functions are also treated as OBJECTS

Porque func y no increment?

En este caso, func es un nombre de parámetro que se utiliza para generalizar la función de orden superior high_ord_func. Esto significa que high_ord_func no está diseñada específicamente para trabajar solo con la función increment, sino que puede aceptar cualquier función que cumpla con el formato requerido.

Al usar el nombre más general func en lugar de increment, se hace que la función high_ord_func sea más genérica y reutilizable. Puedes pasar cualquier función que tome un argumento y devuelva un resultado que se pueda sumar al valor x. Si decides cambiar la función que pasas como argumento, no necesitas cambiar el nombre de la función en el código de high_ord_func.

Por ejemplo, podrías tener otra función llamada double que duplica un número:

pythonCopy code
def double(x):
    return x * 2

result = high_ord_func(2, double)
# Esto dará como resultado 2 + double(2) = 2 + (2 * 2) = 6
print(result)

En este caso, double se pasa como argumento a high_ord_func a través del parámetro func. Esto ilustra la flexibilidad y generalidad que se logra al usar un nombre de parámetro genérico como func en lugar de algo específico como increment.

"""
Validación de datos: Crea una función que tome una lista de datos y una función de validación como entrada. La función de validación debe tomar un dato individual y retornar True si cumple ciertas condiciones o False si no. La función principal debe usar la Higher Order Function para filtrar los datos válidos y devolver una nueva lista con los datos que cumplan con la condición de validación.
"""

def datos(dato):
  return dato

def validar(dato, funcion):
  if dato>=2:
    return True
  else:
    return False

resultado = validar(2, datos)
print("Resultado:", resultado)

Cuando enviamos una funcion como parametro, realmente lo
que estamos haciendo es mandar el dato de la ubicacion en memoria de esa funcion para que python o la funcion de alto nivel acceda a la funcion menor por su identificador en memoria, este identificador se puede ver usando el metodo id

def my_func():
	pass

#objeto en memoria que apunta a la funcion
print(my_func)
--> <function any_func at 0x000001BC2605C5E0>
id(my_func)
--> 1907603391968

Muy bien. Vengo disfrutando la clase, y aprendiendo un montón.

HOF

#-----High order function-------

#funcion dentro de otra funcion
def increment(x):
  return x + 1

def high_order_func(x, func):
  return x + func(x)

result = high_order_func(2, increment)
print(result)
--> 5

# HOF con lambda
increment2 = lambda x: x + 1
high_order_func2 = lambda x, func: x + func(x)
result2 = high_order_func2(2, increment2)
print(result2)
--> 5

# enviar directamente lambda a la HOF
result3 = high_order_func2(2, lambda x: x*4)
print(result3)
--> 10

#A una función se le puede enviar otra función y ejecutarla desde ahí.

def increment(x):
return x +1

def high_ord_func(x, func):
return x + func(x) #Aquí se ejecuta la función

result = high_ord_func(2, increment)

2 + (2 + 1)

print(result)

#Lambda
increment_v2 = lambda x : x + 1
high_ord_func_v2 = lambda x, func: x + func(x)

result = high_ord_func_v2(2, increment_v2)
result = high_ord_func_v2(2, lambda x : x + 2 )
print(result)
result = high_ord_func_v2(2, lambda x : x * 5 )
print(result)

lambda -parámetros de entrada- : función

# Función increment
def increment(x):
    return x + 1

# Función increment usando lambda
increment_v2 = lambda x: x + 1

# Función de orden superior que toma una función como argumento
def high_ord_func(x, func):
    return x + func(x)

# Función de orden superior usando lambda
high_ord_func_v2 = lambda x, func: x + func(x)

# Resultados usando las funciones definidas
result = high_ord_func(2, increment)
print(result)  # 5 (2 + (2 + 1))

result = high_ord_func_v2(2, increment_v2)
print(result)  # Output: 5 (2 + (2 + 1))

result = high_ord_func_v2(2, lambda x: x + 2)
print(result)  # Output: 6 (2 + (2 + 2))

result = high_ord_func_v2(2, lambda x: x * 5)
print(result)  # Output: 12 (2 + (2 * 5))

genial

Este metodo es muy bueno porque te permite ver las funciones de una manera sencilla. Mas adelante, esto sera interesante.

✅

Una función de orden superior es una función que toma una o más funciones como argumentos y/o devuelve una función como resultado. Esto significa que puedes tratar a las funciones como objetos de primera clase en Python y utilizarlas de manera flexible en tu código.

Un ejemplo común de función de orden superior es una función que toma otra función como argumento. Aquí tienes un ejemplo sencillo:

pythonCopy code
def aplicar(funcion, valor):
    return funcion(valor)

def cuadrado(x):
    return x * x

def cubo(x):
    return x * x * x

resultado = aplicar(cuadrado, 5)  # Aplica la función cuadrado a 5
print(resultado)  # Imprime 25

resultado = aplicar(cubo, 3)  # Aplica la función cubo a 3
print(resultado)  # Imprime 27

En este ejemplo, la función aplicar es una función de orden superior porque toma otra función (funcion) como argumento y la aplica a un valor dado (valor). Puedes ver que hemos definido dos funciones, cuadrado y cubo, que realizan operaciones diferentes. Luego, utilizamos la función aplicar para aplicar estas funciones a valores específicos.

Este es solo un ejemplo básico de una función de orden superior. Python proporciona muchas funciones de orden superior incorporadas, como map(), filter(), y sorted(), que te permiten realizar operaciones en listas u otros objetos utilizando funciones personalizadas.

Las funciones de orden superior son poderosas porque te permiten abstraer y reutilizar lógica de manera eficiente, lo que hace que tu código sea más modular y legible. También son útiles en la programación funcional y en la escritura de código más declarativo.

Hice este bloque de código queriendo practicar este concepto, podrían aclararme sí me quedó bien y sí realmente es una HOF. Agradezco cualquier aporte y corrección para seguir aprendiendo<3

def saludar():
    return 'hola'

def saludar_con_nombre(funcion, nombre):
    return saludar() + ' ' + nombre

nombre = 'david'
saludo = saludar_con_nombre(saludar, nombre)
print(saludo) #hola david

High order functions + lambda: Una HOF es una función que puede recibir otras funciones como argumentos y/o devolver funciones como resultados. Las lambdas en este caso pueden usarse como argumentos dentro de las high order function para hacerlo de una forma más dinámica y poder jugar. Esto significa que puedes tratar las funciones como objetos de primera clase en Python, lo que te permite realizar operaciones avanzadas de programación funcional, como mapeo, filtrado y reducción de datos.

EXPLICACION DEL PRIMER EJEMPLO

Es mucho texto pero si tienen dudas sobre el funcionamiento del código vale la pena leerlo.

def incremento(x):
    return x + 1

def hof(x, func):
    return x + func(x)

resultado = hof(2, incremento)
print(resultado)

1. Se define una función llamada incremento(x) que toma un argumento x y devuelve x + 1. En otras palabras, esta función toma un número x y devuelve el número siguiente a x.

2. Se define otra función llamada hof(x, func) que toma dos argumentos: x y func. La función hof toma un número x y una función func, y devuelve x + func(x). Esto significa que toma el número x, aplica la función func a x y luego suma el resultado de func(x) a x.

3. Se llama a la función hof(2, incremento). En este caso, se pasa 2 como el valor de x y incremento como el valor de func. Esto significa que estamos llamando a hof con x = 2 y func = incremento.

4. Dentro de la función hof, se aplica la función func (que es incremento en este caso) a x, que es 2. Entonces, func(2) se convierte en incremento(2), lo cual es 2 + 1, lo que resulta en 3.

5. Luego, se suma x (que es 2) y el resultado de func(2) (que es 3), lo que da como resultado 2 + 3, que es 5.

6. Finalmente, el valor resultante de 5 se almacena en la variable resultado.

7. Se imprime el valor de resultado, que es 5.

En resumen, este código demuestra cómo puedes pasar funciones como argumentos a otras funciones. En este caso, la función hof toma un número y una función como argumentos, aplica la función al número y luego realiza una operación adicional con el resultado. En este ejemplo específico, se utiliza la función incremento para aumentar el número 2 en 1, lo que da como resultado 5.

También se conocen como funciones de orden superior, el cual con ellas se pueden pasar funciones como argumentos para que se ejecuten, manipulen o modifiquen dentro de otra función. Por otra parte, no es necesario declarar funciones, usando la palabra clave lambda se puede pasar como argumento una de una función. Las HOF se usan mucho en el paradigma de programación funcional.

def increment (x):
return x+1

increment_v2 = lambda x: x+1

def high_order_function (x, func):
return x + func(x)

high_order_function_v2 = lambda x, func : x + func (x)

result = high_order_function(2,increment)
print(result)

result = high_order_function_v2(2,increment_v2)
print(result)

result = high_order_function_v2(2, lambda x: x + 2)
print(result)

result = high_order_function_v2 (2,lambda x: x * 5)
print(result)

#other example high order function
def list1():
    lista1 = []
    for i in range(1,10):
        lista1.append(i)
    return lista1
def lista_principal(func):
    lista_madre = [12,32,1232,212,231,12]
    return lista_madre + func()
result = lista_principal(list1)
print(result)

Una función de orden superior, o high-order function en inglés, es una función que puede recibir otras funciones como argumentos y/o devolver funciones como resultado. En Python, las funciones son objetos de primera clase, lo que significa que pueden ser tratadas como cualquier otro objeto, como enteros, cadenas o listas. Esta característica permite que las funciones sean pasadas como argumentos a otras funciones y que sean devueltas como resultados de funciones.

Aquí hay un ejemplo para ilustrar el concepto de high-order function en Python:

def aplicar_operacion(funcion, x, y):
    return funcion(x, y)

def suma(a, b):
    return a + b

def resta(a, b):
    return a - b

resultado = aplicar_operacion(suma, 3, 2)
print(resultado)  # Imprime: 5

resultado = aplicar_operacion(resta, 3, 2)
print(resultado)  # Imprime: 1

En este ejemplo, la función aplicar_operacion es una high-order function porque recibe una función (funcion) como argumento. Dependiendo de la función que se pase como argumento, aplicar_operacion realizará una operación diferente entre los argumentos x e y.

En la primera llamada a aplicar_operacion, se pasa la función suma como argumento, por lo que se realiza una suma entre 3 y 2, devolviendo 5. En la segunda llamada, se pasa la función resta, por lo que se realiza una resta entre 3 y 2, devolviendo 1.

Las high-order functions son especialmente útiles en situaciones donde se necesita abstraer cierta lógica común y parametrizarla mediante funciones. Al utilizar high-order functions, se promueve la reutilización de código y la modularidad, ya que se pueden crear funciones genéricas que trabajen con diferentes implementaciones específicas.

Así pues, una high-order function en Python es aquella que puede recibir funciones como argumentos y/o devolver funciones como resultado. Esto permite una mayor flexibilidad y reutilización de código al parametrizar la lógica de las funciones.

Poderoso concepto para ahorrar líneas

funciones de orden superior, una funcion tambien puede recibir una función que a su ves recibe una función y ser ejecutada

Interesante siempre me costó esto al principio, es super sencillo!

Veo mucho comentario, donde dicen que el profe no es organizado con las explicaciones que hace, que trabaja sobre el mismo código y bla bla bla, por tanto quiero dar mi punto de vista.

• la vida no todo te lo va poner en bandeja de plata, si ves que algo no esta como quiere, hazlo tu, en este caso organiza tu código de tal forma que quede mas explicativo, en el mundo laboral habrá cosas que te va tocar rebuscarte para darle solución, No te acostumbres a que todo te lo tienen que dar a la mano, sal de esa zona.

y ahora les comparto como organicé mi codigo para entenderlo cuando tenga dudas del uso del HOF

def increment(x = 5):
  return x + 1

def higher_order_function(x, func):
  return x + func(x)

#tener presente que el parametro de la funcion es su nombre sin ejecutar, es decir sin los parentesis
result = higher_order_function(2, increment)
print('result → ', result)

#version lambda higher order function
increment_v2 = lambda x : x + 1
higher_order_function_v2 = lambda x, func : x +func(x)
result_v2 = higher_order_function_v2(2, increment_v2)
print('result_v2 → ',result_v2)
# no es necesario definir la funcion lambda para ejecutarla, como parametro de la funcion es suficiente 
higher_order_function_v3 = lambda x, func : x +func(x)
result_v3 = higher_order_function_v3(2, lambda x: x + 1)
print('result_v3 → ', result_v3)

Super el concepto se empieza a ver mas pro.

def increment(x):
  return x + 1

increment_v2 = lambda x: x+1

def high_ord_func(x, func):
  return x + func(x)

high_ord_func_v2 = lambda x, func:x + func(x)

result = high_ord_func(2, increment)
print(result)

result = high_ord_func_v2(2, increment_v2)
print(result)
result = high_ord_func_v2(2, lambda x:x+2)
print(result)
result = high_ord_func_v2(2, lambda x:x*5)
print(result)
  

Mis notas de la clase “13_hof.py”

def increment(x):
  return x + 1 

def high_ord_func(x, func):
  return x + func(x)

result = high_ord_func(2, increment)
# 2 + (2 + 1)
print(result)

# realizar la funcion con lambda en ambas funciones
def increment(x):
  return x + 1 
increment_v2 = lambda x: x + 1

def high_ord_func(x, func):
  return x + func(x)
high_ord_func_v2 = lambda x, func: x + func(x)

result = high_ord_func_v2(2, increment_v2)
# 2 + (2 + 1)
print(result)

# lambda directo a la funcion
result = high_ord_func_v2(lambda x: x + 2)

# change
result = high_ord_func_v2(2, lambda x: x * 5)
print(result)

me explico mejor chat gpt , que esta clase…!!!

@Nicolas Molaina: en los apunted de la clase lo tienes asi high_ord_func_v2 = lambda x, func: x + func(x)… de acuerdo a lo que entiendo deberia ser increment2=lambda x, func: x + func(x)… tal vez esto este generando tambien confusion.

buscando una definicion mas clara, en Python, una Higher Order Function (función de orden superior) es una función que acepta otra función como argumento y/o devuelve una función como resultado.

En otras palabras, una función de orden superior es aquella que trata a una función como si fuera una variable común. Esto permite que las funciones de orden superior sean extremadamente flexibles y útiles, ya que permiten una programación más modular y abierta.

def aplicar_operacion(num, funcion):
    return funcion(num)

def cuadrado(x):
    return x ** 2

resultado = aplicar_operacion(3, cuadrado)
print(resultado)  # Output: 9

En este ejemplo, aplicar_operacion es una función de orden superior que acepta dos argumentos: un número y una función. En este caso, la función es cuadrado, que eleva al cuadrado su argumento. La función aplicar_operacion llama a la función cuadrado con el número dado y devuelve el resultado

Muy buena clase profesor Nicolas 👍

HOF son funciones que toma una o más funciones como argumentos y/o devuelve una función como resultado. Las funciones de orden superior son muy útiles en programación funcional, donde se considera que las funciones son valores de primera clase (es decir, pueden ser asignadas a variables, pasadas como argumentos y devueltas como resultados).

Las funciones de orden superior se utilizan para abstraer el comportamiento común de varias funciones similares, permitiendo la reutilización de código y la construcción de aplicaciones más flexibles y modulares.

Algunos ejemplos comunes de funciones de orden superior en Python son:

• map(función, iterable): toma una función y un iterable como argumentos, y devuelve un nuevo iterable con el resultado de aplicar la función a cada elemento del iterable.

• filter(función, iterable): toma una función y un iterable como argumentos, y devuelve un nuevo iterable que contiene solo los elementos del iterable para los que la función devuelve True.

• reduce(función, iterable): toma una función y un iterable como argumentos, y devuelve un solo valor que es el resultado de aplicar la función a los elementos del iterable de forma acumulativa.

• sorted(iterable, key=función): toma un iterable y una función opcional como argumentos, y devuelve una lista ordenada de los elementos del iterable en función del valor que devuelve la función para cada elemento.

Por ejemplo, podemos definir una función de orden superior que toma una función f y un número x, y devuelve el resultado de aplicar f a x dos veces:

"""Usando la función de orden superior con la función lambda "doble" definida en la pregunta anterior"""

def doble_aplicacion(f, x):
    return f(f(x))
resultado = doble_aplicacion(lambda x: x*2, 3) 

# resultado es 12

En este ejemplo, doble_aplicacion es una función de orden superior porque toma una función (f) como argumento y devuelve el resultado de aplicar f dos veces a un valor (x). Podemos llamar a esta función con diferentes funciones, como la función lambda lambda x: x*2 que definimos anteriormente, para obtener diferentes resultados.

Explicación mas sencilla:
Función de orden superior: es una función que toma una o más funciones como argumentos y/o devuelve una función como resultado.

Funciones anónimas, también conocidas como funciones lambda, son funciones sin nombre que se pueden definir y utilizar en una sola línea de código. Son útiles cuando necesitas definir una función simple y no quieres crear una función con un nombre definido.

Algunas cosas las explico de manera mas complicada, pero busquen en YouTube o en Google, y encontraran explicaciones mas sencillas. Luego regresen aquí y repasen.

def increment(x):
    return x + 1


def increment_v2(x): return x + 1


def high_ord_func(x, func):
    return x + func(x)


result = high_ord_func(2, increment)
print(result)

Excelente clase! Aunque el concepto inicialmente puede tornarse un poco confuso, pero como todo es cuestión de práctica.

Les comparto el código de la clase

# Higher order function: una función dentro de otra función

# A una funcion, le podemos enviar otra funcion como argumento y ejecutarla desde ahi

# Haciendo uso de funciones
def increment(x):
  return x + 1

def high_ord_func(x, func):
  return x + func(x)

result = high_ord_func(2, increment)
# 2 + (2 + 1) = 5
print(result)

# Haciendo uso de labmda functions
increment_v2 = lambda x: x + 1

high_ord_func_v2 = lambda x, func: x + func(x)

result = high_ord_func_v2(2, increment_v2)
print(result)

result = high_ord_func_v2(2, lambda x: x + 2)
print(result)

result = high_ord_func_v2(2, lambda x: x * 5)
print(result)

Así lo hice yo

#Metodo tradicional
def increment(x):
  return x + 1

def high_ord_func(x, func):
  return x + func(x)

result = high_ord_func(2, increment)
# 2 + (2+1)
print(result)

#Con funciones lambda
increment_v2 = lambda x : x + 1
high_ord_func_v2 = lambda x, func: x + func(x)

result2 = high_ord_func_v2(2, increment_v2)
# 2 + (2+1)
print(result2)

print(high_ord_func_v2(2, lambda x : x + 1))
print(high_ord_func_v2(2, lambda x : x + 2))
print(high_ord_func_v2(2, lambda x : x * 3))

Ejemplo del mismo tema con una calculadora.

def fun_operacion():
    operacion = fun_captura()
    return eval(operacion)

def fun_captura():
    numero_operacion = input("Introduce la operación: ")
    return numero_operacion

resultado = fun_operacion()
print(resultado)

Y ahora resumo la calculadora con lambda.

captura = lambda: input("Introduce la operación: ")
operacion = lambda x: eval(x)

resultado = operacion(captura())
print(resultado)

def run():
    x = 2
    y = 3

    def squaring(x):
        return x**2
    
    def aritmetic(y, func):
        return y * (2 + func(x))
    
    result = aritmetic(y,squaring)
    print(result)
#/////////////////////////////////
#/////////////////////////////////
    squaringtwo = lambda x: x**2
    aritmeticstwo = lambda y, func2: y*(2 + func2(x))

    print(aritmeticstwo(y, squaringtwo))

if __name__ == '__main__': 
    run()

'''
HOF
Higher order function
Una funcion dentro de otra funcion
'''

def increment(x):
    return x+1

def higher_ord_func(x,func):
    return x + func(x)

print(higher_ord_func(3,increment))
 
higher_ord_func_v2=lambda x,func:x+func(x)

print(higher_ord_func_v2(3,increment))
print((lambda x,func:x+func(x))(3,increment))

result=higher_ord_func_v2(2,lambda x:x+2)
print(result)
result=higher_ord_func_v2(2,lambda x:x*2)
print(result)

Cuando es que van a poner “Me gusta esta clase”?

Super, me encanto esta clase

yo lo hice de esta forma y me funciono

def increment (x):
    return x+1

increment_v2 =lambda x :x+1

def higher_ord_function(x,func):
    return x + func(x)


result=higher_ord_function(2,increment)
# 2 + (2+1)

result_lambda=higher_ord_function(2,increment_v2)
print(result)
print(result_lambda)

Vaya, vayaaaa, cosa mas interesante

😄

Esto se está poniendo muy cool:

increment = lambda number: number + 1

high_order_function = lambda value, function: value + function(value)

result = high_order_function(5, increment)
# 5 + (5+1)
print(result)

• A higher-order function is a function that takes one or more functions as arguments, or returns a function as its result. In other words, a higher-order function is a function that operates on or with functions.

• Higher-order functions are a useful concept in programming because they allow you to abstract over actions, not just values. This can make it easier to write code that is flexible, reusable, and easy to understand.

Here is an example of a higher-order function in Python that takes a function as an argument:

def apply_twice(func, arg):
  return func(func(arg))

def add_five(x):
  return x + 5

print(apply_twice(add_five, 10))  # Output: 20

• In this example, apply_twice is a higher-order function that takes a function func and an argument arg, and applies func to arg twice. The function add_five is passed as the func argument, and the result is the same as calling add_five(add_five(10)), which is 20.

def increment(x):
  return x + 1

increment_v2 = lambda x: x+1

def high_ord_func(x, func):
  return x + func(x)

high_ord_func_v2 = lambda x, func: x +func(x)

result = high_ord_func(2, increment)
# 2 + (2+1)
print(result)
result = high_ord_func_v2(2, increment_v2)
print(result)
result = high_ord_func_v2(2, lambda x: x+2)
## charge
print(result)
result = high_ord_func_v2(2, lambda x: x*5)
print(result)

me parecen muy utiles para cosas cortas pero no pretender hacer una mega lambda function que despues sea complicado de leer o modificar.

Todos los días aprendemos algo nuevo, el día que digas que ya sabes todo, ese día entraste en zona de confort.
Gracias por sus clases

• Una función se llama función de orden superior si contiene otras funciones como parámetros o funciones de retorno. Es un concepto importante. Python, como lenguaje de programación muy flexible, admite el uso de funciones de orden superior. Hay algunas funciones integradas de orden superior en Python y también podemos definir funciones de orden superior por nosotros mismos.

Geniarl aprender las High order function!