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, x and 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):

myList = [44, 12, 98, 34, 17]                              
newList = []

for i in myList:
    newList[i] = getMod(i)


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))

The result is [4, 2, 8, 4, 7], just as expected.

  • The map function takes two inputs: A function, and a list of arguments to pass to it.
  • map returns a 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 filter()

Here is an example of the filter() function in python. filter() takes in two arguments:

  1. A function object, (in this case a lambda function) which returns a boolean
  2. 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))

This returns [12], 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 reduce()

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

The output here is 720.

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 720.

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 map(), reduce(), and 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.