Lambda Functions in Python

Lambda functions, also known as anonymous functions, are an alternative way of defining functions. Unlike regular functions, lambda functions do not have a name.

In general, they are small functions, and are used in contexts where a function is needed temporarily. For example, when used as parameters for other functions.

Lambda Functions

In Python, lambda functions are defined using the lambda keyword followed by a list of parameters, followed by a colon (:) and an expression.

lambda parameters: expression

For example, we can define a lambda function that calculates the square of a number as follows:

square = lambda x: x * x

This lambda function takes an argument x and returns the result of x * x. Lambda functions are especially useful when we need to pass a function as an argument to another function, as we will see next.

Lambda Functions with Multiple Arguments

In this example, sum is a lambda function that takes two arguments x and y and returns the sum of both.

# Syntax: lambda arguments: expression
sum = lambda x, y: x + y
print(sum(3, 5))  # Output: 8

Examples

Let’s see some examples of how the syntax of lambda functions is used in Python:

Sum of Two Numbers

In this example, we define a lambda function called sum that takes two arguments x and y and returns their sum.

sum = lambda x, y: x + y
print(sum(3, 5))  # Output: 8

Filtering a List

In this example, we use a lambda function within the filter() function to filter the even numbers from a list.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # Output: [2, 4, 6, 8, 10]

Mapping a List

In this example, we use a lambda function within the map() function to calculate the square of each number in a list.

numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # Output: [1, 4, 9, 16, 25]

Lambda Functions vs. Defined Functions

Lambda functions are useful when we need a quick function to perform a simple operation. They are often used in combination with higher-order functions, such as map(), filter(), and reduce().

• Syntax Limitations: Lambda functions are limited to a single expression and cannot contain multiple statements or lines of code.
• Readability: Lambda functions can affect the readability of the code if used excessively or in complicated situations.
• Debugging: Debugging lambda functions may be more difficult compared to functions with explicit names.

In summary, they are very useful for what they are, but don’t use them too liberally 😉