Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Funciones anónimas: lambda

10/21
Recursos

Aportes 109

Preguntas 17

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Si estas leyendo esto, significa que estas a la mitad del camino. ¡No te rindas! Ya solo falta la mitad 😃

Me encanta lo de tener quizes entre módulos

La clase y la explicación del profesor están excelentes para entender este concepto, pero en la vida real es una mala practica usar las funciones lambda de esa manera.

Deberías tener en cuenta que:
.

  1. Las funciones lambda no deberían sustituir a las funciones def en python, usar las funciones lambda para sustituir una funcion def es una mala practica.
    .
  2. lambda != arrow_func.
    Si vienes de Javascript es probable que quieras usar una funcion lambda como si fuera una arrow function, no hagas eso. Una arrow function puede llegar a ser mucho mas completa y estas si pueden sustituir a una función clásica en Javascript.
    .
  3. Las Funciones lambda solo deberían de usarse en caso muy específicos o para competencias de programación en las que tengas que programar lo mas rápido posible.
    .
  4. Por favor lean esto: https://stackoverflow.com/questions/25010167/e731-do-not-assign-a-lambda-expression-use-a-def
    .
  5. En serio es muy importante que lean y entiendan el link del punto anterior si quieren convertirse en unos crack en python!

Suerte y nunca paren de aprender!

He vuelto a esta clase porque respondí mal una pregunta del quiz 😀 ¡Qué increíble! Si algo no nos queda claro, podemos específicamente al asunto que nos falta. Este es un feature muy bueno. ¡Felicitaciones!

En python tenemos el uso de las funciones anónimas, Lambda, es una función sin nombre, sin identificador, pequeña (tiene que ser escrita en una sola línea de código) . Se ve de la siguiente manera:

variable = lambda argument : expresion

La variable que almacena lo que la función lambda retorna, un objeto tipo función.

La palabra clave lambda, un argumento, los argumentos que necesitemos, que son los parámetros que le enviamos a la función y una expresión, que es el código que va a ejecutar.

Dos cosas interesantes, el argumento que va a recibir no necesita paréntesis y no hay que usar return porque la función lambda retorna el valor por defecto.

Si que explica muy bien el profe, recuerdo cuando tome el curso de Python y me confundí mucho y este profe le dedico una clase a esta función, se ve fácil pero si vas empezando puede confundir.

El ejercicio funciona para una sola palabra, si necesitamos verificar una oración podemos probarlo de la siguiente manera:

Si VScode usando la extension para formatear codigo python (autopep8) transforma su codigo lambda a una funcion, pueden resolverlo asi:
https://i.stack.imgur.com/FlEqM.png

🐍 Las funciones anónimas nos permiten tener funciones sin nombre (identificador). En Python son conocidas como funciones lambda.

palindrome = lambda string: string == string[::-1]

Mis apuntes de esta parte 😃

Mi aporte 😃

def run():
    def palindrome(string):
        string = string.replace(' ', '')
       
        return string == string[::-1]
    print(palindrome('aji traga la lagartija'))


if __name__ == '__main__':
    run()

Modifique un poco el código para que el usuario pudiera meter la palabra desde consola y con un pequeño mensaje

print("Dame por favor una palabra y verificare si es palindroma")
palabra=input()
palindrome = lambda string: string == string[::-1]

print(palindrome(palabra))
<h4>Funciones anónimas: lamba</h4>

Son funciones sin nombre. lamba argumentos:expresión

Lambda solamente puede tener 1 expresión.

palindrome = lambda string: string == string[::-1] #Variable stores the function value

print(palindrome('ana')) # returns True

coódigo de arriba es equivalente a:

def palindrome(string):
    return string == string[::-1]

print(palindrome('ana'))

lambda: Es una funcion que solo toma un argumento y su funcion es para abreviar hacer la sintaxys del codigo un poco mas ligera y ahorrar tiempo

Ejemplo:

def area_triangulo(base, altura):
    return (base*altura)/2
triangulo1 = area_triangulo(6,5)
triangulo2 = area_triangulo(4,5)
print(triangulo1)
print(triangulo2)

####### 
Ahora para el ejemplo de lambda vamos a simplificar la anterior funcion de la siguiente forma:

area_triangulo = Lambda base, altura: (base*altura)/2
print(area_triangulo(7.5))

###
A diferencia de la funcion tradicional donde declaramos los argumentos dentro de los parentesis en lambda no hace falta colocarlos y en la expresion donde retorna el valor de la funcion colocamos " : " mas el calculo en este caso, con eso tenemos exactamente la misma funcion con una sintaxys mas resumida

IMPORTANTE Las funciones lambda se utilizan solamente cuando las funciones son basicas en funciones donde se utilicen bucles recursividad, condicionales o alguna otra complejidad no se pueden utilizar

Conceptos avanzados de funciones

Una función es simplemente código que escribimos una vez y aplicamos después en diferentes lugares donde estemos trabajando.

funciones anónimas: Lambda

Lambda son las funciones anónimas que contienen una sola expresión, es decir: funciones sin identificación, sin nombre:

lambda argumento:expresión
  • tenemos la palabra clave lambda
  • un argumento seguido de una expresión donde se colocan los argumentos

En vez de usar def usamos lambda. Estas últimas pueden tener el argumento que nosotros necesitemos, pero una sola línea de expresión.

palindrome = lambda string: string === string[::-1]
print(palindrome("ana"))
#output
True
  1. argumento o parametro que recibe la función para poder acompañado de la palabra clave lambda
  2. expresión con linea de código
  3. variable con identificador, ojo no es de la función, sino de la variable que va a contener un objeto de tipo función que retorna toda la función de python
  • retorna un objeto tipo función. además de ser anónima, para llamarlo, pero el nombre que va a tener esta función con el que se le va a llamar después es la variable de tipo función.
    con funciones normales se vería:
def palindrome(string):
    return string == strig[::-1]
print(palindrome("ana"))
#output
True

pongo el código otra vez para comparar

palindrome = lambda string: string === string[::-1]
print(palindrome("ana"))
#output
True
lamda def
parametro sin paréntesis parametro con parentesis
usar lambda usar def
sin parentesis entre parentesis
identificador como nombre de la variable identificador como nombre de la funcion
sin return palabra return
  • Son funciones de una linea cuyo identificador es la variable.
  • No necesitan ser definidas como una función normal ni que se les pase el argumento (parámetro) entre paréntesis.
  • Retorna un objeto de tipo función
  • Se puede omitir escribir return.
# Ejemplo con palabras compuestas:

palindrome = lambda string: string.replace(' ','').strip().lower() == string.replace(' ','').strip().lower()[::-1]
print(palindrome('luz azul'))

Mi implementación

def is_palindromo(word):
    is_palindromo = lambda string: string == string[::-1]
    return is_palindromo(str.upper(word))

if __name__ == '__main__':
    print(str(is_palindromo(input("Digite una palabra: "))))
def main():
    palindrome = lambda word: word == word[::-1]

    palabra = input('Dame una palabra: ')
    if palindrome(palabra):
        print('Felicitaciones, es palindromo')
    else:
        print('Lo siento, intentalo de nuevo')

if __name__ == '__main__':
    main()

Tal vez llegue tarde pero si estas algo confundido te explicare algo adicional:
.
Existen dos tipos de funciones
.
Funciones declarativas
Funciones expresivas
.
Las funciones declarativas son las que creas con def, con nombre y todo el bloque
.
Las funciones expresivas son las que creas dentro de una variable, son una forma de codificar rápido por así decirlo, y solo sirven en la variable que la contiene
.
Esto lo aprendí del profe Diego de granda, excelente profe, da el curso de JavaScript basico

Me encanta python. Es muy cómodo.

El concepto es igual a las arrow functions de JavaScript con return implícito.

const myFunction = (params) => console.log(params);
my_function = lambda params: print(params)

características de las funciones anónimas
estructura lambda argumentos: expresión
(las funciones lambda pueden **tener mas de un argumento ** aunque solo se puede escribir en una linea de código)

Acá hice nuevamente el palíndromo pero con lambda.

def run():
    palabra = input("Escribe una palabra: ")
    palabra = palabra.replace(' ', '')
    palabra = palabra.lower()
    palindromo = lambda palabra: palabra == palabra[::-1]
    if palindromo(palabra):
        print('es un palindromo')
    else:
        print('no es palindromo')


if __name__ == "__main__":
    run()

Ejemplo del ejercicio de palindromo del curso python basico, con una lambda

palindromo = lambda string: string == string[::-1] 


def run():
    palabra = input("Ingrese una palabra: ")
    palabra = palabra.replace(' ','').lower()
    if palindromo(palabra):
        print("Es palindromo!")
    else:
        print("No es palindromo!")
    
    
if __name__ == '__main__':
    run()

Notas 😄
Funciones anónimas: lambda.

  • Las funciones normales nos sirven para reutilizar código que se aplica en varias secciones. Sin embargo, hay otro tipo de funciones: lambda 😎.

  • Son funciones si nombre o anónimas; estás no tienen un nombre. La estructura en general es:

    lambda argumentos: expresión
    
  • Las funciones lambda pueden tener los argumentos que queramos, pero una sola línea de código. 🤯

  • Ejemplo con palíndromos:

    palindrome = lambda string: string == string[::-1]
    print(palindrome('ana'))
    

    En este caso, palindrome es una variable que guarda un objeto de tipo función, no es la función en si misma.

  • Código de la sesión:

    def main():
        # With normal function
        def palindrome(string):
            return string == string[::-1]
        print('With normal function', palindrome('ana'))
    
        # With lambda function
        palindrome_lambda = lambda string: string == string[::-1]
        print('With lambda variable:', palindrome_lambda('ana'))
    
        # Check type of variable
        print('Type of variable:', type(palindrome_lambda))
    
    if __name__ == '__main__':
        main()
    

Me encantan los quizzes entre modulos. Seria más eficiente si fueran más preguntas ( 10 por ejemplo).

Definir una función Lambda, requiere de un identificador, para que contenga como un objeto tipo función, a nuestra función anónima. Se declara igual que cualquier otra variable, seguidamente contiene una declaración de la función con el Keyword Lambda: justamente después de definir que es una función anónima, ponemos los args que recibe y luego con dos puntos, el proceso que lleva con ellos.

🐍 A continuación mi aporte letal aplicando la lógica de palíndromos:

# Palindrome with lanbda_functions
palindrome = lambda string: string.replace(" ", "").lower() == string.replace(" ", "").lower()[::-1]

print(palindrome("La Tele Letal"))

Creo que allí haría falta hacer la normalización de texto (eliminar espacios, colocar todo el string en minúscula, eliminar acentos, etc.) para poder que la función sirva correctamente.

Para quienes venimos de JavaScript, esto es el equivalente a las ‘Arrow Functions’, Aunque el concepto del mismo en JS es mas complejo que eso, falta ver en proximos cursos si realmente son tan similares

Es genial aprender un lenguaje nuevo!! y lo mejor de todo, el profesor, tiene un claridad espectacular en las explicaciones!

Cómo se menciona en la documentación oficial, las funciones anónimas (lambda) sólo deben ser utilizadas si el código a ejecutar es pequeño (recordar que sólo se admite una línea de código) y, si te da demasiada pereza definir una función.
Siendo el caso, la variable a la que se le asigna el resultado de la función lambda, vendría siendo equivalente al nombre que se le estaría dando a la definición de la función.

>>> print(palindrome("ana"))
True

Entendido a poner en práctica.

Ánimo y a seguir por más. Nunca pares de aprender.

Recordemos que solo una expresión puede tener una función anónima.

En Mac la comilla sencilla me dio un SyntaxError, lo resolví con la doble comilla

una forma de cambiar el orden de expresión y como se ejecuta

# Solucion arear triangulo con lambda

area_triangulo = lambda base,altura: (base*altura)/2

print(area_triangulo(7,10))

#  COMO CREO UNA LAMBDA FUNTION

# 1 Creo la variable
# 2 Palabra clave lambda
# 3 Defino los argumentos que va a recibir la  funcion lambda
#  separados por comas sin parentesis
# 4 Ponemos dos puntos ':' que representara lo que va a retornar
#  la funcion en la variable
# 5 Despues de los puntos ponemos el calculo u operacion que queremos
# que ejecute la funcion

# Solucion Area Tringulo con def

def area_tringulo(base, altura):
    return(base*altura)/2

triagulo1=area_tringulo(5,7)
triagulo2=area_tringulo(9,6)

Las expresiones lambda, también conocidas como “funciones anónimas”, le permiten crear y utilizar una función en una sola línea. Son útiles cuando necesita una función corta que solo usará una vez. Por ejemplo, al utilizar el mapa, filtrar y ordenar los métodos.

Video para complementar:
https://www.youtube.com/watch?v=25ovCm9jKfA

Si no te quedó totalmente claro, en este video lo explica a grandes rasgos:
Lambda

Hey…🐱‍👤

def start_point(x):
    
    palindromo = lambda name_of_something : name_of_something == name_of_something[::-1]
    return palindromo(x)

if __name__ == "__main__":
    name = input('name: ').replace(" ", "").lower()
    print(start_point(name))

Las funciones Lambda pueden tener cualquier número de argumentos, pero solo una expresión.

Código de ejemplo:

Función Lambda para calcular el cuadrado de un número

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

Funcion tradicional para calcular el cuadrado de un numero

def square1(num):
return num ** 2
print(square(5)) # Resultado: 25

En el ejemplo de lambda anterior, lambda x: x ** 2 produce un objeto de función anónimo que se puede asociar con cualquier nombre. Entonces, asociamos el objeto de función con square. De ahora en adelante, podemos llamar al objeto square como cualquier función tradicional, por ejemplo, square(10)


def run(): 

    palindromo = lambda string: string == string[::-1] # La función dice que si el parámetro es el mismo invertido.

    entrada = input('Escribe un palindromo: ')

    if palindromo(entrada) == True:
        print("Es un palindromo")
    else:
        print('No es palindromo')

if __name__ == '__main__':
    run()

Los Quiz son un gran aporte al desarrollo del aprendizaje, orientan el enfoque en lo que el profesor considere debe quedar muy claro y fijo en el alumno.

<def run():
    word = input("Write a palindrome : ")
    word = word.replace(" ","")
    word = word.lower()
    palindrome = lambda word: word == word[ ::-1]
    if palindrome(word) == True:
        print (" the string is palindrome")
    else:
        print (" the word is not palindrome")

if __name__=="__main__":
    run()> 

En este otro ejemplo juego un poco con las lambdas para ver como usarlas con operadores ternarios

def message_returned(is_palindromo):
    message = lambda string: "Es un palindromo" if is_palindromo else "No es palindromo"
    print(message(is_palindromo))

def is_palindromo(word):
    is_palindromo = lambda string: string == string[::-1]
    return  message_returned(is_palindromo(str.upper(word)))

if __name__ == '__main__':
    is_palindromo(input("Digite una palabra: "))
def run():
    word = input("write a word: ")

    palindrom = lambda string: string == string[::-1]

    print(f"the word is {'palindrom' if palindrom(word) else 'NOT a palindrom'}")


if __name__ == '__main__':
    run()

Intente escribirlo con el menor numero de lineas posible, es muy entretenido aunque de mala practica segun lei.

¡Hola! Por si alguien quedó con la duda de como usar la función lambda les dejo un ejemplo adicional

# Funciones anónimas

#funcion anónima palíndromo

def run():

    print('funcion anónima palíndromo')
    palindrome = lambda string: string == string[::-1]
    print(palindrome('ana'))

    print()

    y = 1
    x = 3

    print('sumar con una expresion lambda dos numeros')
    sumar_lambda = lambda a, b: a + b
    print(f'La suma de {y} + {x} es igual a {sumar_lambda(x, y)}')

    print()

    print('Exponente de un numero con lambda')
    exponent_lambda = lambda a, b: a**b
    print(f'La exponenciacion de {x} a la {y} es: {exponent_lambda(x, y)}')




if __name__ == '__main__':
    run()

Las funciones anónimas o Lambdas son funciones que no cuentan con un nombre. Su estructura esa:

lambda argumentos: expresión

Estas funciones solo pueden tener una línea de código.

Aquí mi aporte

def run ():
    palindromo = lambda string:string == string[::-1]
    usuario_pal = str (input("Coloque aqui su frase/palabra para saber si es palindromo: "))
    print(palindromo(usuario_pal))

if __name__=='__main__':
    run()

Las funciones lambda (funciones anonimas) no deberían sustituir a las funciones def en python, usar las funciones lambda para sustituir una funcion def es una mala practica.

Las Funciones lambda solo deberían de usarse en caso muy específicos o para competencias de programación en las que tengas que programar lo mas rápido posible.

Suma de dos números con funciones lambda 😃

def run():
    myVar = lambda num1, num2: num1 + num2
    print(myVar(2,3))

if __name__ == "__main__":
    run()

-> 5
  • Funciones lambda[1].
lambda arguments: commandline

Palindromo con lambda o funciones anónimas

def run():
    word = input('Enter a word: ').strip().upper().replace(' ', '')

    palindrome = lambda string: string == string[::-1]
    
    if palindrome(word) == True:
        print('Is palindrome')
    else: 
        print('Is not palindrome')

if __name__ == '__main__':
    run()

Argumentos cuantos sean necesarios, pero solo 1 sola expresion

Si quiere aplicar funciones anónimas a más de dos variables:

suma = lambda a,b : a+b

suma (4,4)
8

palindrome = lambda string: string.lower().replace(" “,”") == string[::-1].lower().replace(" “,”")

Excelente, gracias

muy clara la explicación y aun mas importante, el ejemplo poniendo palindrome como se pondría en una función normal para hacer el comparativo.

Determinar sí una cadena de texto es un palíndromo

def run():
prueba = 'tonot’
es_palindromo = lambda cadena: cadena == cadena[::-1] # retorna un booleano
if es_palindromo(prueba) == True:
print(prueba, ‘es palíndromo’)
else:
print(prueba, ‘no es palíndromo’)

if name == ‘main’:
run()

Gran valor de lambda, aunque parece chino al principio XD

Es como un list comprenhension pero con funciones!!!

De tanto leer comentarios acerca de las buenas prácticas con las funciones lambdas, llegue a este vídeo que si bien no tiene que ver con lambdas, sí habla de herramientas para tener una codificación XD

En programación una función anónima es una definición de función que no está vinculada a un identificador

los tres jercicios anteriores

    list_comprension = [pow(x,2) for x in range(100)]
    print(list_comprension)

    print("\n")
    
    dic_comprension = {x:pow(x,3) for x in range(100) if x%3 != 0}
    print(dic_comprension)

    print("\n")
    
    dic = {x:math.sqrt(x) for x in range(100)}
    print(dic)
palindrome = lambda string: string == string[::-1]

print(palindrome('ana'))

Palindromo

def run():
    palabra = input('Escribe una palabra o frase \n')
    palabra = palabra.replace(' ','') # Quitar los espacios
    palabra = palabra.lower()# Pasar las palabras a minuscula
    palindromo = lambda x: x == x[::-1]
    if palindromo(palabra):
        print(f'{palabra} es un palindromo')
    else:
        print(f'{palabra} no es un palindromo')
      
 
 
if __name__ == '__main__':
    run() 

Funciones anónimas: lambda
Las funciones lambda son funciones anónimas que se declaran en una sola línea a diferencia de las funciones normales de python que se declaran usando def(). Las funciones lambda constan de 3 partes en su sintaxis:
• Se coloca la palabra reservada lambda
• Seguido de la palabra reservada se colocan todos los argumentos que vamos a ocupar en nuestra función, se pueden tener varios argumentos, después de declarar todos los argumentos se coloca :
• Finalmente, después de los dos puntos se coloca la expresión que es lo que realmente va a ejecutar nuestra función lambda.

Una implementación muy sencilla con input()

#!/usr/bin/env python

palindrome = lambda string: string == string[::-1]
""" Is the word a palindrome? """

def main():
    string = input("Input a word: ")
    print(palindrome(string))

if __name__ == '__main__':
    main()

no entendí, ah no si, ya entendí, no espera, no, ah no no sí , mmmm ah ya! , ahora sí ya ya , ya esta . entendí 👍🏽

Al fin entiendo el concepto lambda

Indica la palindromía sin importar los espacios o las mayusculas… 😃

palindrome = lambda texto: texto.lower().replace(" ", "") == texto[::-1].lower().replace(" ", "")

print(palindrome("A n a"))

La verdad que Facundo explica excelente, he tomado varios cursos de programación y con el me quedan claro los conceptos de una.

def run():
    palindrome = lambda string: string == string[::-1]
    print(palindrome('solos'))


if __name__ == '__main__':
    run()

Muy buena clase.

Convertirte_en_un_crack_profesional lamdba string:platzi

def run():
	palindrome = lambda string: string.strip().lower() == string[::-1].strip().lower()

if __name__=="__main__":
    run()

Podemos usar los métodos de String en las mismas funciones anónimas:

    palindrome = lambda string: string.upper() == string.upper()[::-1]
    print(palindrome("Ana"))

Cool

my_dict = {i: i**0.5 for i un Ranger(1,1001)} print (my_dict)

Está excelente este curso. Tanto el contenido como la metodología.

Lo interesante de las lambda functions, es el no tener que colocar el return.

En el caso de python nuestras funciones Lambda, no pueden ser más larga que una línea de código.

Podemos crear también funciones que no tienen un nombre: Las funciones Lambda

while True:
        palindromo = lambda string : string == string[::-1]
        print(palindromo(input("Palindromo: ")))

Osea que las funciones lambda serían como las funciones flecha de JS?

Agregando lo siguiente:

palindrome = lambda string: (string[::-1]).replace(" ", "").lower() == string.replace(" ", "").lower()

Esta función anónima acepta los siguientes casos:

  • Ana
  • ana lava lana
  • Amar da drama
def main():
    palindome = lambda string: string == string[::-1]
    print(palindome('ana'))

if __name__ == "__main__":
    main()

sintaxis

Es lo que sería en JavaScript las arrow functions. Excelente conocer esto y sobre todo la particularidad de que solo puede escribirse en una sola línea de código.

Comprobación de número primo usando función lambda

import math

# Si p es un número primo, entonces (p − 1)! ≡ -1 (mod p)
# John Wilson 

prime_number = lambda p: math.factorial(p - 1) % p == (-1 % p) and p > 1

def main():
    while True:    
        p = int(input('Escribe un número: '))
        if prime_number(p):
            print('Es primo')
        else:
            print('No es primo')

if __name__ == '__main__':
    main()

Que gran profesor, Facu