Funciones anónimas: lambda

Funciones anónimas

Aquí os dejo una forma sencilla de ver una lambda function:

Creo que la intención de Nicolás era imprimir la variable ‘result’ y no el número 11.

result = increment(10)
print(result)

¿Que es lambda?
Son conocidas como Funciones Anónimas o lambdas, en donde no tienen un identificador o no tienen un nombre, se puede definir su estructura de la siguiente manera: lambda argumentos: expresión, las funciones lambda pueden tener los argumentos que se requieran pero solo una linea de código o una expresión.

Sintaxis

lambda arguments : expression

Queremos incrementar el valor de una serie según la cantidad que le hayamos dado para ello tenemos el siguiente ejemplo:

def increment(x):
  return x + 1

increment_v2 = lambda x : x + 1

result = increment_v2(20)
print(result)

_Producción:_
21

La función lambda puede tomar cualquier cantidad de argumentos, pero solo puede tener una expresión.

datos_completos = lambda name, last_name, age, countrie: f'Sus datos completos son {name.title()} {last_name.title()} tiene {age} años y vive en {countrie.title()}'
text = datos_completos('camilo', 'mejia', 35, 'colombia')
print(text)

_Producción:_
Sus datos completos son Camilo Mejia tiene 35 años y vive en Colombia

Lectura de Apoyo

¡El curso está muy bueno!.
y por fin entendí la función lambda. XD

si quieres llamar directamente a lamba seria asi:

(lambda x : x * 2)(3)

y daria 6

Una combinación de funciones lambda con recursividad para generar un valor de la serie Fibonacci:

fibonacci = lambda x: 0 if x == 0 else 1 if x < 3 else fibonacci(x - 1) + fibonacci(x - 2)
print(fibonacci(int(input('Enter a number: '))))

Por curiosidad trate de probar si podía usar las lambdas en una list comprehension, y si, se pueden usar.
acá les dejo el código.

sqr = lambda x: x ** 2
lst = [sqr(i) for i in range(1, 10)]
print(lst)

En Python, una función lambda es una forma abreviada de crear funciones anónimas, es decir, funciones que no tienen un nombre. Las funciones lambda se utilizan a menudo en conjunción con las funciones integradas de Python como “map”, “filter” y “reduce”, así como en combinación con funciones de orden superior como “sorted” y “min”.

La sintaxis de una función lambda es la siguiente:

lambda argumentos: expresión

donde “argumentos” es una lista de argumentos y “expresión” es la expresión a evaluar.

Por ejemplo, podríamos usar una función lambda para elevar un número a una potencia específica:

power = lambda x, y: x ** y
print(power(2, 3)) # 8

Una de las ventajas de las funciones lambda es que son muy concisas, lo que las hace ideales para tareas simples y fácilmente legibles. Sin embargo, para tareas más complejas, se recomienda utilizar funciones normales, ya que son más fáciles de depurar y mantener.

En resumen, las funciones lambda en Python proporcionan una forma conveniente y concisa de crear funciones anónimas para tareas simples y puntuales, y son especialmente útiles al trabajar con funciones de orden superior.

Aquí algunos ejemplos extra …!

# Lamdba - Basico
lambda_func = lambda x : x**2
print(lambda_func(3))
print(lambda_func(4))

# Lamdba - Intermedio
lambda_func = lambda x: True if x**2 >= 10 else False
print(lambda_func(3))
print(lambda_func(4))

# Lambda - Avanzado
# n = 1 M.Aritmetica / 2 M.Geometrica / 3 M.Armonica"
# No se puede definir el "elif" dentro de una funcion lamdba
lambda_func = lambda  x,y,z,n : (x+y+z)/3 if n == 1 else ( (x*y*z)**(1/3) if n == 2 else (3/((1/x)+(1/y)+(1/z)))) 
print('Media Aritmética => ' + str(lambda_func(4,5,6,1)))
print('Media Geométrica => ' + str(lambda_func(4,5,6,2)))
print('Media Armónica => ' + str(lambda_func(4,5,6,3)))

Por si acaso aun ocupan un poco mas de informacion sobre las funciones lambdas , les dejo este link para apoyar lo visto.
https://www.freecodecamp.org/news/python-lambda-function-explained/

También se pueden usar inputs en la función lambda, por ejemplo:

full_name = lambda a, b : f'Su nombre es {a.title()} {b.title()}'
text = full_name(input('Nombre: '), input('Apellido: '))
print(text)

¡Saludos!

En el minuto 6:38 la idea es poner como parámetro la variable result, no el valor 11. Igual es resultado es 11.

Creo que por la emoción se creo este laspsus. 🤣

Una pequeña forma de hacer lambda en python.

Funciones Lambda
Las funciones Lambda son funciones anónimas que solo pueden contener una expresión.

¿Cuando y por qué usarlas
Puedes ahorrar escribir varias lineas de código si solo necesitas hacer una expresión **corta ** con una función. En ese caso puedes usar Lambda.

Ejemplo
De una lista, si quiere saber cuáles son los números positivos.

mi_lista = [18, -3, 5, 0, -1, 12]
lista_nueva = list(filter(lambda x: x > 0, mi_lista))
print(lista_nueva) # [18, 5, 12]

Otro ejemplo
Función que duplique el valor de números en una lista.

mi_lista = [1, 2, 3, 4, 5, 6]
lista_nueva = list(map(lambda x: x * 2, mi_lista))
print(lista_nueva)  # [2, 4, 6, 8, 10, 12]

def valumen(length, width, x):  #Pasar de esto
    return length * width * x

volumen = lambda lengh,width,x: lengh*width*x #A esto

print(volumen(10,10,10))

"En mi opinion, una funcion lambda es util cuando tenemos varios parametros que a su vez, devuelven un solo resultado.

cuando tengas varias cosas que comprobar, considera usar una funcion def.

me dio mucha risa que el imprimio el 11 no el result jajajaj xD

Aqui una solucion al ultimo ejercicio de la clase

full_name = lambda name, last_name : f'full name is: {name.title()} {last_name.title()}'

text = full_name(input('Nombre(s) => '), input('Apellido => '))
print(text)

1.Sin retorno y solo impresion, asignandole los valores directamente
2.Con retorno e impresion, asignandole los valores directamente

sumar_v1=(lambda x,y:print(x+y))(3,4)
sumar_v2=(lambda x,y:x+y)(3,4)
print(sumar_v2)

def increment(x):
    return x + 1
result = increment(10)
print(result)

#Funcion lambda debemos definir parametros de entrada y de salida

fun=lambda x : x + 2
print(fun(10))

full_name = lambda name,last_name: f'el nombre es {name} {last_name} '
print(full_name('Didio','Perdomo'))

Que profesor tan malooo!
poco carisma y pesima forma de explicar.

Funciones anónimas: lambda

La función lambda en Python es una forma concisa de definir funciones anónimas (sin nombre) y pequeñas en una sola línea de código. Estas funciones son útiles cuando necesitas una función simple para realizar una tarea específica y no deseas crear una función con un nombre completo usando la sintaxis def.

La sintaxis básica de una función lambda es la siguiente:

lambda argumentos: expresion

Donde:

• argumentos son los parámetros de entrada de la función.
• expresion es la operación que la función realizará y cuyo resultado se devolverá.

Aquí hay algunos ejemplos para ilustrar cómo se utiliza la función lambda:

1. Función lambda simple:

suma = lambda a, b: a + b 
resultado = suma(5, 3)  # El resultado será 8

1. Ordenamiento de una lista de tuplas utilizando una función lambda:

personas = [('Juan', 25), ('María', 30), ('Carlos', 28)] 
personas.sort(key=lambda x: x[1]) # Ordenará la lista de personas por edad

1. Uso de función lambda en map():

numeros = [1, 2, 3, 4, 5] 
cuadrados = list(map(lambda x: x ** 2, numeros)) # Resultado: [1, 4, 9, 16, 25]

1. Filtrado de elementos utilizando función lambda en filter():

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
pares = list(filter(lambda x: x % 2 == 0, numeros)) # Resultado: [2, 4, 6, 8, 10]

Las funciones lambda son particularmente útiles cuando necesitas una función simple para un uso específico, como en combinación con funciones de orden superior como map(), filter() y sorted(). Sin embargo, si la función que necesitas es más compleja o será reutilizada en múltiples lugares, es preferible utilizar una función definida con def para tener un código más legible y mantenible.

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

filtrado = filter(lambda x: x % 2 != 0, mi_lista)

list(filtrado)
# [1, 3, 5, 7, 9]

¿Qué son las funciones lambda o anónimas?

• Las funciones lambda o anónimas, son un tipo de sintaxis especial para crear funciones cortas con una sintaxis reducida, las cuales vamos a necesitar en
• Tkinter y en muchas otras cosas.

¿Por qué se llaman anónimas estas funciones?
Esto es debido a que no hace falta darles un nombre.

Diferencia entre función normal y lambda de Python

• Aparte de la sintaxis reducida, la diferencia fundamental entre una función normal y una lambda, es que las funciones lambda no pueden tener más de una expresión. Sí que pueden tener tantos argumentos como queramos.

Ejemplo de uso de función lambda

• Aquí tienes una función de multiplicación normal y corriente. Muy sencilla.

def multiplicacion(numero1,numero2):
	return numero1 * numero2

lambda numero1, numero2 : numero1 * numero2

FUNCIONES ANONIMAS LAMBDA:

-Una función lambda es una pequeña función anónima.
-Una función lambda puede tomar cualquier cantidad de argumentos, pero solo puede tener una
expresión.

-Sintaxis:
    var_name = lambda arguments : expression

-Las funciones Lambda pueden tomar cualquier número de argumentos

-¿Por qué utilizar las funciones de Lambda?
    El poder de lambda se muestra mejor cuando los usa como una función anónima dentro de
    otra función.

Las funciones lambdas también son conocidas como funciones anónimas, pues carecen de un nombre.
.
En Python una función se define con la palabra reservada def seguida del nombre de la función, en cambio una función anónima se crea utilizando la palabra reservada lambda seguida de los argumentos de dicha función.
.

Características de una función lambda

• Se pueden definir con n número de parámetros pero solo pueden evaluar y retornar una sola expresión.
• Se puede utilizar (mandar llamar) en cualquier parte como una función normal.
• Suelen utilizarse como argumentos de otras funciones.

.

Regresar el cuadrado de una número:
Función normal

def square(num):
	sqr = num ** 2
	return sqr

print(square(3))
# 9

Función lambda

square = lambda x : x ** 2
print(square(3))
# 9

funciones anónimas

‘’‘funcion normal’’’

def increment(x):
    return x + 1

result = increment(10)
print(11)

‘’‘funcion lambda’’’

x = lambda x : x + 1
print(x(5))

‘’‘funcion lambda’’’

fullName = lambda name,  lastName : f'Your full name is { name } { lastName }'
print(fullName('Ayriel', 'Noriega'))

la principal característica de una función Lambda es recibir los valores y reducir la sintaxis

La función lambda en Python se utiliza comúnmente en situaciones donde se requieren funciones pequeñas y temporales. Algunos casos típicos incluyen:

1. Funciones de Orden Superior: Las funciones lambda son convenientes cuando necesitas pasar funciones como argumentos a otras funciones, como map, filter, y sorted. Por ejemplo, para aplicar una operación simple a cada elemento de una lista, puedes usar una función lambda con map.

   # Utilizando lambda con map
   numeros = [1, 2, 3, 4, 5]
   cuadrados = list(map(lambda x: x**2, numeros))
   print(cuadrados)  # Salida: [1, 4, 9, 16, 25]
   

2. Funciones Anónimas en Expresiones: Cuando solo necesitas una función para una expresión simple y no quieres definir una función completa con def. Esto puede hacer que el código sea más conciso y legible en ciertos contextos.

   # Utilizando lambda en una expresión
   suma = lambda x, y: x + y
   resultado = suma(3, 4)
   print(resultado)  # Salida: 7
   

3. Callbacks Rápidos: En situaciones en las que necesitas pasar una función como argumento a otra función y no planeas reutilizar la función definida.

   # Utilizando lambda como callback
   def operacion_binaria(a, b, operador):
       return operador(a, b)
   
   resultado = operacion_binaria(5, 3, lambda x, y: x * y)
   print(resultado)  # Salida: 15
   

Es importante destacar que las funciones def son más versátiles y pueden contener múltiples expresiones y declaraciones, mientras que las funciones lambda están limitadas a una sola expresión. Además, las funciones definidas con def pueden tener un nombre, lo que las hace más útiles para casos donde se necesita reutilización o claridad en el código. En general, la elección entre def y lambda dependerá de la complejidad del código y de la necesidad de reutilización.

Me encanto la forma de usar lambda en nuestra linea de codigo. Aprendi mucho con respecto a su uso. No imagine que fuera posible simplificar varias lineas en algo tan simple.

✅

Yo digo que en la lambda en la entrada esta también el parámetro y en la salida esta el argumento.

def incrementar(x):
return x + 1

incrementar2 = lambda x : x+1

resultado = incrementar(10)
print (resultado)

resultado = incrementar2(20)
print(resultado)

full_name = lambda name , last_name: f"su nombre es {name.title()} {last_name.title()}"
text = full_name (“camilo” , “salazar”)
print(text)

En Python, una función lambda es una función anónima que se puede definir en una sola línea de código. Estas funciones son útiles cuando se necesita una función temporal para una operación simple. La sintaxis de una función lambda es la siguiente: lambda argumentos: expresión.

Por ejemplo, si quisieras crear una función que sume dos números, podrías hacerlo de la siguiente manera:

suma = lambda x, y: x + y

De esta manera, la variable suma se convierte en una función que toma dos argumentos y devuelve su suma.

Una función lambda en Python es una forma de crear funciones anónimas y de una sola expresión sin necesidad de definirlas formalmente con la declaración def. Las funciones lambda son útiles cuando necesitas una función simple y pequeña para realizar una tarea específica, como una operación matemática, una transformación de datos o una función de ordenamiento.

A veces suelo tener preguntas, pero como soy nuevo viendo el curso no hay quien responda, entonces me gustaría que los profes de Platzi este más atentos.

Una lambda es una función anónima en programación. En lugar de definir una función con un nombre, una lambda se define de forma concisa utilizando la palabra clave lambda .

Las funciones lambda, también conocidas como funciones anónimas, son funciones pequeñas y de una sola expresión en Python. A diferencia de las funciones regulares definidas con la palabra clave def , las funciones lambda se definen utilizando la palabra clave lambda.

La sintaxis básica de una función lambda es la siguiente:

lambda argumentos: expresión

La función lambda toma una serie de argumentos separados por comas, seguidos por dos puntos y una expresión. La expresión es evaluada y su resultado es devuelto automáticamente como resultado de la función lambda.

Una característica clave de las funciones lambda es que no requieren un nombre, de ahí su nombre de “funciones anónimas”. Por lo tanto, generalmente se utilizan en situaciones donde se requiere una función simple y no es necesario asignarle un nombre.

Las funciones lambda son útiles cuando se necesita una función temporal o se desea pasar una función como argumento a otra función, como en el caso de las funciones map(), filter(), sort() y otras funciones de orden superior en Python.

Aquí hay un ejemplo para ilustrar el uso de una función lambda:

# Definir una función lambda que suma dos números
sumar = lambda x, y: x + y

# Utilizar la función lambda
resultado = sumar(3, 5)
print(resultado)  # Imprime: 8

En este ejemplo, la función lambda sumar toma dos argumentos x e y y devuelve su suma. La función lambda se asigna a la variable sumar y luego se utiliza como una función normal para sumar dos números.

Llegue al punto de no entender nada.

Tiene una forma más parecida a las funciones vistas en matemáticas.

Excelente!

Me parece muy útil la función lambda. Hice una operación utilizando la función lambda con dos variables x, y, para la fórmula: x^2 + 2xy + y^2

operacion = lambda x, y : x ** 2 + 2 * x * y + y ** 2
result = operacion(2, 4)
print(result)

full_name= lambda name,last_name :f'Full name is {name.title()} {last_name.title()}'
text=full_name('david','gonzalez')
print(text)

Este código utiliza una función lambda para crear una función anónima llamada full_name. La función lambda toma dos argumentos, name (nombre) y last_name (apellido), y devuelve una cadena formateada que representa el nombre completo.

Aquí está la explicación paso a paso:

La línea full_name = lambda name, last_name: f’Full name is {name.title()} {last_name.title()}’ define la función lambda full_name. Toma dos argumentos, name y last_name, y utiliza una expresión para crear una cadena formateada que contiene el nombre completo. El método .title() se utiliza para asegurarse de que la primera letra de cada palabra esté en mayúscula.

La siguiente línea, text = full_name(‘david’, ‘gonzalez’), invoca la función full_name pasando los valores ‘david’ y ‘gonzalez’ como argumentos. Esto asigna el resultado de la función lambda a la variable text.

Por último, la línea print(text) imprime el contenido de la variable text, que en este caso sería la cadena formateada con el nombre completo.

En resumen, este código utiliza una función lambda para definir una función anónima que toma dos argumentos y devuelve una cadena formateada con el nombre completo. Luego, se invoca esta función lambda con valores específicos y se imprime el resultado. En este caso, el resultado impreso sería “Full name is David Gonzalez”.

a colocarla mas en uso para ver mejor su potencial. Aunque uno de esos es usarla dentro de una function y cuando tengamos solo una expression, sera mas optima nuestras functions.

es como una funcion flecha en javascript

Aquí mis notas y mis propios ejemplos:

# Sintaxis básica
sumar = lambda value_one, value_two: value_one + value_two
print(sumar(1,2))# 3

# Lambdas como datos de retorno
def sum_three_values(val_one):
    return lambda val_two, val_three: val_one + val_two + val_three
print(sum_three_values(5)(1,2))# 8

# Lambdas como argumentos

def sum_three_values_2(val_one: int, f):
    return val_one + f(1,2)

print(sum_three_values_2(1, sumar))# 4

# Auto invocación
print(
    (lambda val_one, val_two: val_one + val_two)(1,2)# Auto invocación
)# 3

les comparto mi aporte usando inputs!!!

full_name = lambda name, last_name: f'tu nombre completo es: {name} {last_name}'
name = input('¿ingresa tu primer nombre?: ').title()
last_name = input('¿ingresa tu primer apellido?: ').title()

answer = full_name(name, last_name)
print(answer)

Buenas, pongo una modificación del mismo codigo pero con unos input para el name y last_name

full_name = lambda name, last_name: f'Full name: {name.title()} {last_name.title()}'

text1 = full_name(input(),input())
print(text1)```

Ya hay muchos “aportes” copiados y pegados de chatgpt 😦

La verdad es que es muy evidente que las funciones lambda son como las list comprehension, es una forma de ahorrar líneas de código, además de que es muy facil leerlas. Por lo explicado en clase, el nombre de la función no es importante

Mal explicado!

La función lambda en Python es una función anónima que se puede crear de forma rápida y sencilla sin necesidad de definir una función con un nombre específico.

La sintaxis básica de una función lambda en Python es la siguiente:

lambda arguments: expression

Donde “arguments” son los argumentos de la función separados por comas, y “expression” es la expresión que se evalúa y devuelve como resultado de la función.

Por ejemplo, para crear una función lambda que calcule el cuadrado de un número, se puede escribir lo siguiente:

square = lambda x: x**2

En este caso, la función lambda toma un argumento “x” y devuelve el resultado de elevar al cuadrado ese argumento. La función lambda “square” se puede llamar de la misma forma que cualquier otra función definida en Python:

result = square(5)
print(result) # Output: 25

La función lambda es especialmente útil cuando se necesita crear una función rápida y sencilla para realizar alguna tarea específica, como filtrar una lista, ordenar elementos, etc.

Una función anónima es una función que no tiene un nombre definido en el código. En el caso de Python, una función anónima se crea con la palabra clave “lambda”.

A diferencia de las funciones regulares que se definen con la palabra clave “def”, las funciones lambda no necesitan ser definidas con un nombre específico y no tienen un encabezado de función completo con un bloque de código definido.

En lugar de eso, las funciones lambda se pueden definir y utilizar de forma inmediata en una sola línea de código. Por ejemplo, la siguiente expresión define una función lambda que suma dos números:

lambda x, y: x + y

Esta función se puede utilizar de la siguiente manera:

sumar = lambda x, y: x + y
resultado = sumar(3, 5)
print(resultado) # Output: 8

En este ejemplo, se ha creado una función lambda y se ha asignado a la variable “sumar”, que se puede llamar como cualquier otra función. La función lambda toma dos argumentos y devuelve su suma como resultado.

Las funciones lambda son útiles cuando se necesita una función simple y rápida que no requiere un nombre definido en el código.

😃

full_name = lambda name, last_name: f'You full name is: {name} {last_name}'
name = input('¿What is your name?: ').title()
last_name = input('¿What is your last name?: ').title()

answer = full_name(name, last_name)
print(answer)

funcion lambda en unas oraciones

• Es una función lambda es una función anónima y pequeña que se puede definir en una sola línea de código.
• Estas funciones son útiles cuando necesitas una función temporal para realizar una tarea específica, ya que no necesitas crear una función con un nombre específico para hacerlo.
• Las funciones lambda son útiles para realizar operaciones simples y rápidas, como filtrar una lista, ordenar una lista o realizar una operación matemática simple.

• Esto me recuerda mucho a las arrow funcitions de JAVASCRIPT

const suma = (a,b) => a+b;

# calculadora con lambda xd

n1,n2=int(input()),int(input())
suma = lambda x, y : x + y
resultado = suma(n1,n2)
print(resultado)

Las funciones lambda en Python son funciones anónimas (sin nombre) que se definen en una sola línea de código. También se conocen como funciones lambda o funciones anónimas porque no tienen un nombre definido, a diferencia de las funciones regulares que se definen con la palabra clave “def” y se nombran con un identificador.

La sintaxis:

1. lambda argumentos: expresión
2. variable = lambda  funcion: return

Donde “argumentos” son los parámetros de la función, y “expresión” es la operación que se realiza con los argumentos (return). La función lambda toma los argumentos y devuelve el resultado de la expresión.

• Las funciones lambda son útiles cuando necesitamos definir una función de una sola línea y no queremos escribir una función separada para ello. También son comunes en programación funcional y se utilizan a menudo con funciones de orden superior como map(), filter(), y reduce().

A lambda function is a small anonymous function.
A lambda function can take any number of arguments, but can only have one expression.

La principal diferencia vs las funciones que ya conocíamos, además de ser anónima, es que las lambda function solo retornan una expresión.

# Funciones anónimas: lambda
# https://www.w3schools.com/python/python_lambda.asp

# Funcion
def increment(x):
  return x + 1

# Transformar en lambda function
increment_v2 = lambda x: x + 1

result = increment(10)
print(result)

result = increment_v2(20)
print(result)

full_name = lambda name, last_name: f'Full name is {name.title()} {last_name.title()}' # La funcion title hace que las palabras inicien en mayuscula

text = full_name("sara maria", "mejia sanchez")
print(text)

Las expresiones lambda en Python son una forma corta de declarar funciones pequeñas y anónimas (no es necesario proporcionar un nombre para las funciones lambda). Las funciones Lambda se comportan como funciones normales declaradas con la palabra clave def .

Una lambda function es una función delegada, que se puede definir cuando nuestra función solo contiene una línea de código

Veamos…

#Function
def increment(x):
  return x + 1
result = increment(10)
print('Function => ',result)

#Lambda
increment_v2 = lambda x : x + 1
resultv2 = increment_v2(30)
print('Function type LAMBDA => ',resultv2)

#Lambda Dos
full_name = lambda name, last_name : f'Full Name is => {name.title()} {last_name.title()}'
text = full_name('lionel', 'messi')
print(text)

#Funciones anonimas:lambda

def increment(x):
    return x+1
print(increment(10))

#Transformando a lamda

increment_v2=lambda x:x+1
resultado=increment_v2(20)
print(resultado)

full_name=lambda nombre,apellido:f"Hola el nombre completo es {nombre.title()} {apellido.title()}"
nombre_mio=full_name("Alejandro","Moreno")
print(nombre_mio)

Mi aporte con funciones filter, map e input.

#son funciones que se realizan sin necesidad de definirlas (def) por lo que son denominadas tambien funciones anonimas 


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

pares = lambda x: x % 2 == 0  #creando una funcion que muestre los pares
z = list(filter(pares,list1))  #con filter podemos filtrar un iterable con una funcion. Se utiliza list para poder generar el formato.
print(z)

por2 = lambda x: x * 2  #funcion que multiplica por 2 cada elemento
x = list(map(por2, list1)) #map realiza el procedimiento iterable segun la funcion
print(x)


#con dos argumentos que evalua el texto ingresado por el usuario
full_name = lambda name, last_name: f"full name is {name.title()} {last_name.title()}"

name_user = str(input("Digite el nombre: "))
last_name_user = str(input("Digite el apellido: "))
texto = full_name(name_user, last_name_user)
print(texto)

Hola tú

También puedes asignar unos parámetros por defecto a los parámetros con lambda function:

full_name = lambda name = "Alvaro", lastName = "Garzón" : f"Fullname: {name.title()} {lastName.title()}"
print(full_name())

hahahaha minimo error de Nico en el minuto 1:45, imprime en pantalla literalmente el numero 11 esperando que esa fuera la respuesta

LLegamos en donde se pone buena la cosa

Saludos

def increment (x):
    return x + 1

increment2 = lambda x : x + 2
result_2 = increment2(20)
print(result_2)

result = increment (10)
print(result)

full_name = lambda name, full : f' El nombre completo es {name.title()} {full.title()}'

text = full_name('oliver', 'huayamave')
print(text)

También se puede añadir typing usando esta sintaxis

from typing import Callable

# [[tipo de variable que recibe], tipo de variable que retorna]
increment:Callable[[int], int] = lambda x: x+1

Creo que aqui seguro nicolás queria imprimir result.

te sere sincero … me estresa que cada que demuestra algo, deja todo el codigo arriba; aveces me pierdo y debo pausar el video para entender el hilo de lo que esta haciendo o que cambio… la metodologia de enseñanza siempre es bueno optimizarla… me pregunto si penso que sentira el que no sabe codigo encontrar tanta letra en la parte de resultados

lo de print(11) fue a proposito?

#Como se hace antiguamente:
def increment(x):
  return x+1

result=increment(20)
print(result)

#Con lambda
increment2 = lambda x: x+1
result2=increment2(10)
print(result2)

#Lambda con nombre: 

nombre_completo = lambda nombre, apellido: "El nombre completo es {} {}".format(
    nombre.title(), apellido.title()
)
nombre=nombre_completo("jefferson", "cortés gutiérrez")
print(nombre)

Las funciones lambda no pueden contener sentencias múltiples y sólo pueden devolver una expresión.

• Correcto:

add = lambda x, y: x + y

• Incorrecto

add = lambda x, y:
  print(x + y)

multiplicar = lambda x: x * 5

result = multiplicar(10)

print(result)

¡Buenísimas las lambda functions!

def increment(x):
  return x + 1
  
increment_v2 = lambda x : x +1 

result = increment(10)
print(11)

result = increment_v2(20)
print(result)

full_name = lambda name,middle_name, last_name: f'full name is {name.title()} {middle_name.title()} {last_name.title()}'

text = full_name('Mario','Alexander','Perez casa')
print(text)

Una variable también puede contener una función

No es buena idea pasarse los 80 caracteres en una sola linea, como aquí lo hacen en la linea 13

Funciones Lambda

#--------Lambda-----------

#funcion incremento
def increment(x):
  return x + 1

result = increment(10)
print(result)
--> 11

# funcion incremento con lambda funtions
increment2 = lambda x: x + 1
result = increment2(20)
print(result)
--> 21

# funcion lambda que recibe dos valores
full_name = lambda name, last_name: f'el nombre completo es {name.title()} {last_name.title()}'

text = full_name('jose', 'alvarez')
print(text)
--> el nombre completo es Jose Alvarez

Excelente explicación🤗

Algo de historia…

"Las expresiones lambda en Python y otros lenguajes de programación tienen sus raíces en el cálculo lambda, un modelo de computación inventado por Alonzo Church.

Alonzo Church formalizó el cálculo lambda, un lenguaje basado en la abstracción pura, en la década de 1930. Las funciones lambda también se conocen como abstracciones lambda, una referencia directa al modelo de abstracción de la creación original de Alonzo Church.
El cálculo lambda puede codificar cualquier cálculo. Es Turing completo, pero contrariamente al concepto de máquina de Turing, es puro y no guarda ningún estado."

Fuente

def increment (*arg):
    return sum(arg)

num = lambda *arg: sum(arg*2)

print(f'lambda * 2 es {num(4,5,6,7)}')
print(increment(4,5,6,7))

Estan geniales las funciones lambda

Hermoso el código:

increment_v2 = lambda x : x + 1
result = increment_v2(20)
print(result)

full_name = lambda name, last_name: f'Full name is {name.title()} and Last name is {last_name.title()}'
text = full_name('antonio','demarco bonino')
print(text)

def increment(x):
  return x+1


result = increment(9)
print(result)


incrementv2 = lambda x : x+1
result = incrementv2(20)
print(result)

full_name = lambda name, last_name : name+' '+last_name
nombre=full_name('Camilo', 'Rico')
print(nombre)

full_name = lambda name, last_name : f'Full name is {name.title()} {last_name.upper()}'
nombre=full_name('Camilo', 'Rico')
print(nombre)

Usar lambda de esa forma es un anti-patron.
La clase esta buenísima para entender como funciona lambda pero la guía de estilos de código en python o como mejor se le conoce PEP8 (algo así como la biblia de python 😂) nos dice que no deberíamos asignar a lambda (meter a lambda dentro de una variable), en su lugar deberíamos la función normal de python.
.

Este podría ser un ejemplo del uso de lambda en un entorno laboral

lista_de_tuplas = [(2, 'b'), (3, 'c'), (1, 'a'), (4, 'd')]

# Ordenar la lista por el primer elemento de la tupla
ordenado_por_primer_elemento = sorted(lista_de_tuplas, key=lambda tupla: tupla[0])

print(ordenado_por_primer_elemento) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

En este ejemplo, la función lambda se utiliza como argumento de la función sorted() para especificar la clave de ordenamiento. La lambda toma cada tupla como entrada y devuelve el valor del primer elemento de la tupla, que se utiliza para ordenar la lista. El resultado final es la lista ordenado_por_primer_elemento que contiene las mismas tuplas, pero en orden ascendente por el valor del primer elemento de la tupla.
.
Aca pueden leer la regla especifica de la PEP 8 que nos dice que no deberiamos “meter” a lambda en una variable