What are lambda functions?
In Python, lambda functions are a syntax that allows the use of anonymous functions in ones code.
Lambda functions take any number of inputs, perform some computation on these inputs, and return the result of this computation.
To best illustrate the uses of lambda functions, let’s first examine a normal function which takes in two numbers,
y, multiplies them, and returns the result.
# Function that multiplies two numbers def multiplyTwoNumbers(x, y): return x*y
Now let’s see how this looks as a lambda function:
>> g = lambda x, y: x*y >> print(g(6, 3)) >> 18
- Lambda functions contain an implicit return call
- Lambda functions contain only one expression
Why use lambda functions?
Lambda functions work best when a computation needs to be done but does not necessitate a separate function.
In our last example we only saved one line of code. Let’s showcase the true strengths of anonymous functions.
For our example, say we need to find the value of
x % 10 for every element
x in a list. Using traditional code, it may look something like this.
# This code preforms modulus 10 on every element in a list def getMod(x): return(x%10) myList = [44, 12, 98, 34, 17] newList =  for i in myList: newList[i] = getMod(i) print(newList)
This gives us
[4, 2, 8, 4, 7]. Let’s clean this up with a lambda expression.
# This code preforms modulus 10 on every element in a list myList = [44, 12, 98, 34, 17] newList = list(map(lambda x: x%10, myList)) print(newList)
The result is
[4, 2, 8, 4, 7], just as expected.
mapfunction takes two inputs: A function, and a list of arguments to pass to it.
map object, so we cast it to a list in order to read it.
- Lambda functions can declared inline and thrown away. No declaration or variable assignment required.
Lambda functions and
Here is an example of the
filter() function in python.
filter() takes in two arguments:
- A function object, (in this case a lambda function) which returns a boolean
- Iterable list of aguments
filter() works similarly to
map() except only the values for which our lambda function returns
True are added to the list
Let’s say we wanted to filter out numbers that are not a multiple of three.
myList = [44, 12, 98, 34, 17] newList =list(filter(lambda x: x%3 == 0, myList)) print(newList)
, which makes sense because it is the only multiple of three in our list. This is certainly better than a for loop with a traditionally defined function!
Lambda functions and
The reduce function is used when one wishes to perform a rolling computation on an iterable. For example, let’s say you wanted to find the product of numbers in a list. Using traditional python, it might look something like this:
# code to find the product of all elements in a list myList = [2, 3, 4, 5, 6] total = 1 for i in myList: total = total*i print(total)
The output here is
The same process using a lambda expression and
reduce() looks something like
from functools import reduce myList = [2, 3, 4, 5, 6] print(reduce(lambda x,y: x*y , myList))
Again, the output is
Basically, the reduce function is performing the following operation:
$$ ((((2 * 3) * 4 ) * 5) * 6) $$
Pretty nifty, huh? 😄
Lambda functions. Used by CS students trying to flex on their classmates? Indeed. Valuable and useful tool to optimize quick calculations? Hell yes.
We learned how to leverage lambda expressions with the
filter() functions to make quick data processing a breeze. These are some pretty trivial examples but the concept can be extrapolated to fit real world applications.