Lambda Functions in Python

What are Lambda Functions?

In Python, we use the lambda keyword to declare an anonymous function, which is why we refer to them as "lambda functions". An anonymous function refers to a function declared with no name. Although syntactically they look different, lambda functions behave in the same way as regular functions that are declared using the def keyword. The following are the characteristics of Python lambda functions:

  • A lambda function can take any number of arguments, but they contain only a single expression. An expression is a piece of code executed by the lambda function, which may or may not return any value.
  • Lambda functions can be used to return function objects.
  • Syntactically, lambda functions are restricted to only a single expression.

In this article, we will discuss Python's lambda functions in detail, as well as show examples of how to use them.

Creating a Lambda Function

We use the following syntax to declare a lambda function:

lambda argument(s): expression  

As stated above, we can have any number of arguments but only a single expression. The lambda operator cannot have any statements and it returns a function object that we can assign to any variable.

For example:

remainder = lambda num: num % 2

print(remainder(5))  

Output

1  

In this code the lambda num: num % 2 is the lambda function. The num is the argument while num % 2 is the expression that is evaluated and the result of the expression is returned. The expression gets the modulus of the input parameter by 2. Providing 5 as the parameter, which is divided by 2, we get a remainder of 1.

You should notice that the lambda function in the above script has not been assigned any name. It simply returns a function object which is assigned to the identifier remainder. However, despite being anonymous, it was possible for us to call it in the same way that we call a normal function. The statement:

lambda num: num % 2  

Is similar to the following:

def remainder(num):  
    return num % 2

Here is another example of a lambda function:

product = lambda x, y : x * y

print(product(2, 3))  

Output

6  

The lambda function defined above returns the product of the values of the two arguments.

Why Use Lambda Functions?

Lambda functions are used when you need a function for a short period of time. This is commonly used when you want to pass a function as an argument to higher-order functions, that is, functions that take other functions as their arguments.

The use of anonymous function inside another function is explained in the following example:

def testfunc(num):  
    return lambda x : x * num

In the above example, we have a function that takes one argument, and the argument is to be multiplied with a number that is unknown. Let us demonstrate how to use the above function:

def testfunc(num):  
    return lambda x : x * num

result1 = testfunc(10)

print(result1(9))  

Output

90  

In the above script, we use a lambda function to multiply the number we pass by 10. The same function can be used to multiply the number by 1000:

def testfunc(num):  
  return lambda x : x * num

result2 = testfunc(1000)

print(result2(9))  

Output

9000  

It is possible for us to use the testfunc() function to define the above two lambda functions within a single program:

def testfunc(num):  
    return lambda x : x * num

result1 = testfunc(10)  
result2 = testfunc(1000)

print(result1(9))  
print(result2(9))  

Output

90  
9000  

Lambda functions can be used together with Python's built-in functions like map(), filter() etc.

In the following section, we will be discussing how to use lambda functions with various Python built-in functions.

The filter() Function

The Python's filter() function takes a lambda function together with a list as the arguments. It has the following syntax:

filter(object, iterable)  

The object here should be a lambda function which returns a boolean value. The object will be called for every item in the iterable to do the evaluation. The result is either a True or a False for every item. Note that the function can only take one iterable as the input.

A lambda function, along with the list to be evaluated, is passed to the filter() function. The filter() function returns a list of those elements that return True when evaluated by the lambda funtion. Consider the example given below:

numbers_list = [2, 6, 8, 10, 11, 4, 12, 7, 13, 17, 0, 3, 21]

filtered_list = list(filter(lambda num: (num > 7), numbers_list))

print(filtered_list)  

Output

[8, 10, 11, 12, 13, 17, 21]

In the above example, we have created a list named numbers_list with a list of integers. We have created a lambda function to check for the integers that are greater than 7. This lambda function has been passed to the filter() function as the argument and the results from this filtering have been saved into a new list named filtered_list.

The map() Function

The map() function is another built-in function that takes a function object and a list. The syntax of map function is as follows:

map(object, iterable_1, iterable_2, ...)  

The iterable to the map() function can be a dictionary, a list, etc. The map() function basically maps every item in the input iterable to the corresponding item in the output iterable, according to the logic defined by the lambda function. Consider the following example:

numbers_list = [2, 6, 8, 10, 11, 4, 12, 7, 13, 17, 0, 3, 21]

mapped_list = list(map(lambda num: num % 2, numbers_list))

print(mapped_list)  

Output

[0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1]

In the script above, we have a list numbers_list, which consists of random numbers. We then call the map() function and pass it a lambda function as the argument. The lambda function calculates the remainder after dividing each number by 2. The result of the mapping is stored in a list named mapped_list. Finally, we print out the contents of the list.

Conclusion

In Python, a lambda function is a single-line function declared with no name, which can have any number of arguments, but it can only have one expression. Such a function is capable of behaving similarly to a regular function declared using the Python's def keyword. Often times a lambda function is passed as an argument to another function.

In this article we explained the syntax, use-cases, and examples of commonly used lambda functions.

Author image
Kenya
I am a programmer by profession. I am highly interested in Python, Java, Data Science and Machine learning. If you need help in any of these, don't hesitate to contact me: [email protected]