Python Funciones Lambda con EJEMPLOS

¿En qué consiste la función Lambda? Python?

A Función Lambda en Python La programación es una función anónima o una función que no tiene nombre. Es una función pequeña y restringida que no tiene más de una línea. Al igual que una función normal, una función Lambda puede tener varios argumentos con una expresión.

In Python, las expresiones lambda (o formas lambda) se utilizan para construir funciones anónimas. Para ello utilizará el lambda palabra clave (tal como la usas def para definir funciones normales). Cada función anónima que definas en Python tendrá 3 partes esenciales:

• La palabra clave lambda.
• Los parámetros (o variables vinculadas), y
• El cuerpo funcional.

Una función lambda puede tener cualquier número de parámetros, pero el cuerpo de la función solo puede contener uno expresión. Además, una lambda se escribe en una sola línea de código y también se puede invocar inmediatamente. Verá todo esto en acción en los próximos ejemplos.

Sintaxis y ejemplos

La sintaxis formal para escribir una función lambda es la siguiente:

lambda p1, p2: expression

Aquí, p1 y p2 son los parámetros que se pasan a la función lambda. Puede agregar tantos o pocos parámetros como necesite.

However, notice that we do not use brackets around the parameters as we do with regular functions. The last part (expression) is any valid Python expression that operates on the parameters you provide to the function.

Ejemplo

Ahora que ya conoces las lambdas, probémoslo con un ejemplo. Entonces, abre tu IDLE y escribe lo siguiente:

adder = lambda x, y: x + y
print (adder (1, 2))

Code Explicación

Aquí, definimos una variable que contendrá el resultado devuelto por la función lambda.

1. La palabra clave lambda utilizada para definir una función anónima.

2. xey son los parámetros que pasamos a la función lambda.

3. Este es el cuerpo de la función, que agrega los 2 parámetros que pasamos. Observe que es una expresión única. No se pueden escribir varias declaraciones en el cuerpo de una función lambda.

4. Llamamos a la función e imprimimos el valor devuelto.

Ejemplo

That was a basic example to understand the fundamentals and syntax of lambda. Let us now try to print out a lambda and see the result. Again, open your IDLE y escribe lo siguiente:

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

Ahora guarde su archivo y presione F5 para ejecutar el programa. Este es el resultado que debería obtener.

Salida:

<function <lambda> at 0x00000185C3BF81E0>

What is happening here? Let us look at the code to understand further.

Code Explicación:

1. Here, we define a cadena that you will pass as a parameter to the lambda.

2. We declare a lambda that calls a print statement and prints the result.

But why does the program not print the string we pass? This is because the lambda itself returns a function object. In this example, the lambda is not being , que son by the print function but is simply volver the function object and the memory location where it is stored. That is what gets printed at the console.

Ejemplo

Sin embargo, si escribes un programa como este:

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

And run it by hitting F5, you will see an output like this.

Salida:

some kind of a useless lambda

Now, the lambda is being called, and the string we pass gets printed at the console. But what is that weird syntax, and why is the lambda definition covered in brackets? Let us understand that now.

Code Explicación:

1. Here is the same string we defined in the previous example.

2. In this part, we are defining a lambda and calling it immediately by passing the string as an argument. This is something called an IIFE, and you will learn more about it in the upcoming sections of this tutorial.

Ejemplo

Let us look at a final example to understand how lambdas and regular functions are executed. So, open your IDLE y en un nuevo archivo escribe lo siguiente:

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

Now, save the file and hit F5 to run the program. If you did not make any mistakes, the output should be something like this.

Salida:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Explicación:

1. A function called guru that takes another function as the first parameter and any other arguments following it.

2. printer_one is a simple function which prints the parameter passed to it and returns it.

3. printer_two is similar to printer_one but without the return statement.

4. In this part, we are calling the guru function and passing the printer functions and a string as parameters.

5. This is the syntax to achieve the fourth step (i.e., calling the guru function) but using lambdas.

En la siguiente sección, aprenderá cómo utilizar funciones lambda con mapa(), reducir(), y filtrar() in Python.

Usando lambdas con Python incorporados

Las funciones Lambda proporcionan una forma elegante y poderosa de realizar operaciones utilizando métodos integrados en Python. Es posible porque las lambdas pueden invocarse inmediatamente y pasarse como argumento a estas funciones.

IIFE en Python lambda

IFE son las siglas de Invocó inmediatamente la ejecución de la función. It means that a lambda function is callable as soon as it is defined. Let us understand this with an example; fire up your IDLE y escribe lo siguiente:

 (lambda x: x + x)(2)

Aquí está el resultado y la explicación del código:

Esta capacidad de las lambdas para ser invocadas inmediatamente le permite usarlas dentro de funciones como map() y reduce(). Es útil porque es posible que no desee volver a utilizar estas funciones.

lambdas en filtro()

La función de filtro se utiliza para seleccionar algunos elementos particulares de una secuencia de elementos. La secuencia puede ser cualquier iterador como listas, conjuntos, tuplas, etc.

The elements which will be selected are based on some pre-defined constraint. It takes 2 parameters:

• Una función que define la restricción de filtrado.
• Una secuencia (cualquier iterador como listas, tuplas, etc.)

Por ejemplo,

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

Aquí está el resultado:

[10, 8, 7, 5, 11]

Code Explicación:

1. En la primera declaración, definimos una lista llamada secuencias que contiene algunos números.

2. Aquí, declaramos una variable llamada filtered_result, que almacenará los valores filtrados devueltos por la función filter().

3. Una función lambda que se ejecuta en cada elemento de la lista y devuelve verdadero si es mayor que 4.

4. Imprime el resultado devuelto por la función de filtro.

lambdas en el mapa()

The map function is used to apply a particular operation to every element in a sequence. Like filter(), it also takes 2 parameters:

1. A function that defines the operation to perform on the elements
2. Una o más secuencias

Por ejemplo, aquí hay un programa que imprime los cuadrados de los números en una lista dada:

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

Salida:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

Code Explicación:

1. Here, we define a list called sequences which contains some numbers.

2. We declare a variable called filtered_result which will store the mapped values.

3. A lambda function which runs on each element of the list and returns the square of that number.

4. Print the result returned by the map function.

lambdas en reducir()

La función reduce, al igual que map(), se utiliza para aplicar una operación a cada elemento de una secuencia. Sin embargo, difiere de map en su funcionamiento. Estos son los pasos que sigue la función reduce() para calcular un resultado:

Paso 1) Realizar la operación definida en los 2 primeros elementos de la secuencia.

Paso 2) Save this result.

Paso 3) Realizar la operación con el resultado guardado y el siguiente elemento de la secuencia.

Paso 4) Repita hasta que no queden más elementos.

También toma dos parámetros:

1. Una función que define la operación a realizar
2. Una secuencia (cualquier iterador como listas, tuplas, etc.)

Por ejemplo, aquí hay un programa que devuelve el producto de todos los elementos de una lista:

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

Aquí está el resultado:

120

Code Explicación:

1. Import reduce from the functools module.

2. Here, we define a list called sequences which contains some numbers.

3. We declare a variable called product which will store the reduced value.

4. A lambda function that runs on each element of the list. It will return the product of that number as per the previous result.

5. Print the result returned by the reduce function.

¿Por qué (y por qué no) utilizar funciones lambda?

Como verá en la siguiente sección, las lambdas se tratan de la misma manera que las funciones regulares a nivel de intérprete. En cierto modo, se podría decir que las lambdas proporcionan una sintaxis compacta para escribir funciones que devuelven una única expresión.

However, you should know when it is a good idea to use lambdas and when to avoid them. In this section, you will learn some of the design principles used by Python developers when writing lambdas.

One of the most common use cases for lambdas is in functional programming, as Python admite un paradigma (o estilo) de programación conocido como programación funcional.

It allows you to provide a function as a parameter to another function (for example, in map, filter, etc.). In such cases, using lambdas offers an elegant way to create a one-time function and pass it as the parameter.

¿Cuándo no deberías usar Lambda?

Nunca debe escribir funciones lambda complicadas en un entorno de producción. Será muy difícil para los programadores que mantienen su código descifrarlo. Si crea expresiones complejas de una sola línea, sería una práctica mucho mejor definir una función adecuada. Como práctica recomendada, debe recordar que el código simple siempre es mejor que el código complejo.

Lambdas frente a funciones regulares

As previously stated, lambdas are just functions which do not have an identifier bound to them. In simpler words, they are functions with no names (hence, anonymous). Here is a table to illustrate the difference between lambdas and regular functions in Python.

lambda x : x + x

def (x) :
return x + x 

Explicación de las diferencias.

La principal diferencia entre una función lambda y una función regular es que la función lambda evalúa solo una expresión y genera un objeto de función. En consecuencia, podemos nombrar el resultado de la función lambda y usarlo en nuestro programa como lo hicimos en el ejemplo anterior.

Una función normal para el ejemplo anterior se vería así:

def adder (x, y):
return x + y 
print (adder (1, 2))

Aquí tenemos que definir un nombre para la función que devoluciones el resultado cuando nosotros Llame it. A lambda function does not contain a return statement because it will have only a single expression which is always returned by default. You do not even have to assign a lambda either, as it can be immediately invoked (see the previous section). As you will see, lambdas become particularly powerful when we use them with PythonFunciones integradas.

Sin embargo, es posible que todavía te preguntes en qué se diferencian las lambdas de una función que devuelve una sola expresión (como la anterior). A nivel de intérprete no hay mucha diferencia. Puede parecer sorprendente, pero cualquier función lambda que defina en Python es tratada como una función normal por el intérprete.

At the bytecode level, the two definitions are handled in the same way by the Python interpreter. Now, you cannot name a function lambda porque está reservado por Python, but any other function name will yield the same bytecode.

Preguntas Frecuentes