Utility of lambda function in Python?

The W3Schools example is a case of currying . Certainly you can achieve the same output doing it the way you propose, but what (I suppose) the first example wants to demonstrate is the possibility of applying functional programming techniques in Python.

For the latter it lambdahelps quite a bit, since it may be unnecessary to define a regular function (using defit and giving it a name), when our goal is to obtain things such as closures or currying .

Let's take an example to see this better, since certainly the W3Schools example says a lot and a little at the same time.

Imagine that you have a program where there is a class Person, which has an attribute age, and you are constantly filtering people objects according to their ages. You could have a function that implements currying and that allows you (at least) the following three benefits:

• Reuse the code responsible for doing the filtering (sticking to the DRY principle )
• Reduce the number of function parameters. The fewer arguments a function has, the better. Quoting Robert (Uncle Bob) Martin (2008, p. 40):

The ideal number of arguments to a function is zero (nyladic) [...] Arguments are hard. They take a lot of conceptual power. That's the reason why I deleted most of them...

• Allow to have clear and expressive names for each function responsible for doing each thing.

The implementation would look like this:

def filter_older_than(age):
    return lambda iterable: [person for person in iterable if person.age > age]


filter_older_than_five = filter_older_than(5)
filter_adults = filter_older_than(18)
filter_elderly = filter_older_than(60)


person_list = [Person(35), Person(6), Person(16), Person(65)]

# En algún lugar de tu código:
filter_elderly(person_list)


# ... y en algún otro lugar de tu código:
filter_adults(person_list)

As you can see, the use of lambdamade the implementation much more direct. Thanks to this we didn't have the need to define a separate function whose only intention is to be returned to allow currying .

Of course we could have implemented the code above with an Object Oriented paradigm, having a parent class Filtrowith the method filtrar(), which serves as an interface, and have child classes that specialize and override that method according to each case.

It is valid? Of course, but the implementation used the functional paradigm is too. Therein, in my opinion, lies the beauty of this language: in the flexibility it provides.

Another common use oflambda

In my experience, where I have seen the most use of anonymous functions is when providing callables (or callables) for the parameter keyof built- in ordering functions. For example:

>>> persons_sorted_by_age = sorted(person_list, key=lambda person: person.age)
>>> persons_sorted_by_age
[Person(age=6), Person(age=16), Person(age=35), Person(age=65)]

There is a clear advantage of having lambda, being able to define and use a function right where it is needed.

_{Be careful, in this case I prefer the use of operators.attrgetter, but the use of is equally lambdawidespread for this purpose.}

What is?

In Python, lambdait is a way to define anonymous functions, they receive and return parameters

It has the following syntax

lambda parámetros : expresión

examples

In the following example, we can return a number multiplied with another with a functionlambda

multiplyNumb = lambda n : n * 5

The above example is equivalent to defining a function as follows

def multiplyNumb(n):
    return n * 5

But, there are specific cases where we can return a function

def multiplyNumb(n):
    return lambda a : a * n

In this case it multiplyNumbreturns a function , so we could do the following

firstNumb = multiplyNumb(2)

In this case, we have a function stored in firstNumb, since the main function returns a lambda function , the value of firstNuumbwill be

lambda a : a * 2

The 2 because we gave the first function "2" as a parameter, so nit is replaced with 2

Then, we only have to call the function to define the value ofa

To define it we simply call the function again, knowing that it will receive a parameter which will be the value ofa

firstNumb(20)

The result will finally be 40, because we have called the lambda function and we have given it 20 so that it interprets it with the value of a, then it returns the 2 that we had multiplied with the parameter that we gave it

Why use lambda?

There are specific cases in which we have to return a function, if this is not your case, the example you gave would suffice

def myfunc(a, n):
  return a * n 

print(myfunc(3, 11))

But, if we have to return a function specifically, we uselambda

def sayHello(firstName):
    return lambda lastName : "Hola " + firstName + " " + lastName

sayHelloFstPart = sayHello("John")
print(sayHelloFstPart("Doe"))

Result

Hola John Doe

When you say that they are anonymous functions, do you mean that they are functions that don't have a name by which to call their execution like this MyFunction()?

They are said to be anonymous functions because they do not have a name to be called by, they are returned by a function or assigned to a variable.

(lambda a : 5 * a)(5)

In the example above, a function is defined lambdaand called, if it is not given a name, it cannot be called

The parentheses so that (5)it is not considered as part of the functionlambda

Then we define the function like this

(lambda a : 5 * a)

And we add parentheses to call the function

(lambda a : 5 * a)(5)

It will return 25, since we are calling the function passing me "5" as a parameter

Lambda functions are not a concept unique to Python. They are typical of functional programming , where it is common for you to pass functions as parameters to other functions, or to return a function as the result of calling another function.

Although the concept of returning a function is strange, and its fields of application could be considered "advanced" (decorators, closures, even the possibility of completely avoiding OOP and allowing to maintain state in function variables instead of in object attributes ), the concept of passing a function as a parameter is easier to understand.

For example, imagine that you want to make a function that times how long it takes to execute another function that receives it as a parameter (and for simplicity we will assume that the function it receives as a parameter has no parameters). So it would be something like this:

import time
def cronometra(funcion_a_cronometrar):
  antes = time.time()
  resultado = funcion_a_cronometrar()
  despues = time.time()
  print("Ha tardado", despues-antes)
  return resultado  # Retornamos el resultado que originalmente devolvía la función

We can now use it to time any "normal" named function, such as:

def sumar_100_numeros():
  total = 0
  for n in range(100):
     total += n
  return total


cronometra(sumar_100_numeros)

Notice a very important detail . To the function cronometra()we are passing the name of the function to time. A typical mistake would be to write cronometra(sumar_100_numeros()). This would be wrong because in this case we would be calling sumar_100_numeros() before , to then pass the result to cronometra(). This would give an error, since that result would be an integer, and not a function, so when you cronometratry to call funcion_a_cronometrar()it it would break, since an integer cannot be called.

In functional programming it is common to pass functions as parameters of other functions. In the Python standard library itself you have the functions sorted(), max()or min()that admit a parameter called keywhich would be the function that should be used on each element of the list to sort, before sorting it. Internally it sorted()will call that function for each item in the list, and use the result of that call to compare the items to each other.

This allows us, for example, to order a list of tuples by their second element:

lista = [(2, 0), (1, 100), (200, 1)]

# Escribimos una función que recibe un elemento de la lista
# y retorna el segundo valor de la tupla
def segundo_valor_tupla(tupla):
   return tupla[1]

# Usamos esa función para ordenar
print(sorted(lista, key=segundo_valor_tupla))

Result:

[(2, 0), (200, 1), (1, 100)]

So far we have talked about functions as parameters and lambdas have not appeared anywhere. When is a lambda useful?

The answer is: when the function that I am going to define is not usable in any other part of the code, and I only define it for that particular case.

In this case, the function does not need a name because it will be received as a parameter, and the parameter already has a name (for example key, in the case of sorted(), or funcion_a_cronometrarin our first example). It is through the name of the parameter that we will invoke the function. His "real" name is irrelevant.

In that case I can use a lambda function. However in Python lambda functions are quite special. In any other language, a lambda could have conditionals, loops, etc... Their only characteristic would be that they have no name, and that they are assigned to a parameter (or returned as a result). On the other hand, in python it is not possible to write the function code in the place where the parameter would go because python does not have curly braces , and therefore we cannot use "inline" control structures. Therefore, python lambdas are very limited and can only be an expression.

lambda parametros: expresion

would be equivalent to the function

def _anonima_(parametros):
   return expresion

So we could rewrite our sort example with a lambda like this:

print(sorted(lista, key=lambda tupla: tupla[1]))

Another usage example

Another example would be to perform partial padding of parameters, which will be understood with the first example that I put before, that of the function that timed another function.

In that example, the function cronometra()is limited to calling funcion_a_cronometrar()without arguments, which was good for timing sumar_100_numeros, but what if I want to time, without changing the function cronometra(), a function that receives parameters, such as:

def sumar_m_numeros(m):
  total = 0
  for n in range(m):
    total += n
  return total

In this case I can't do cronometra(sumar_m_numeros)it because I wouldn't be passing any parameter and it would give an error, but I can't either cronometra(sumar_m_numeros(1000)), because in this case I would call the function first and pass the result to cronometra(), instead of passing the function to it.

The solution would be to create a "dumb" function that takes no parameters and internally calls sumar_m_numeros(1000), and pass that "dumb" function to cronometra().

Change "dumb" to lambda and we're done:

cronometra(lambda: sumar_m_numeros(1000))

Stop to think about this example for a moment. What we're passing to cronometra()is not the result of execute sumar_m_numeros(1000), but a function (the lambda) that hasn't been executed yet. When cronometra()you invoke funcion_a_cronometrar()it, it will be calling the lambda, and at that moment, when executing the lambda, the expression will be evaluated, sumar_m_numeros(1000)calling this function for the first time.

This pattern is often seen when we need to pass another function that doesn't receive parameters to a function, but want to execute one that does. A typical place you see this is when binding actions to buttons in a GUI like Tkinter.