How to use if, else & elif in Python Lambda Functions

Python is a versatile and powerful programming language known for its simplicity and readability. One of the key features that make Python stand out is its support for lambda functions, which are anonymous functions that can be created on the fly. Lambda functions offer a concise and elegant way to define small, one−line functions without the need for a formal function definition. These functions can be used in various scenarios to enhance code readability and maintainability.

In this tutorial, we will delve into the fascinating world of lambda functions in Python and explore how to incorporate if, else, and elif statements within them. We will walk through examples and explanations to showcase the usage of if, else, and elif in lambda functions, highlighting their syntax and illustrating the output they produce. So, let's dive in and let's get an understanding of if, else, and elif statements and their role in controlling the flow of code execution.

How to use if, else & elif in Python Lambda Functions

A lambda function in Python is an anonymous function that can be defined in a single line of code without a formal function name. It is commonly used for creating small, inline functions for tasks that don't require a full function definition. Lambda functions are often used in combination with higher−order functions or in scenarios where a quick function definition is needed.

The general structure of a lambda function with if, else, and elif follows the following format:

lambda arguments: expression if condition else expression

Let's break down this structure:

• The `lambda` keyword is used to define the lambda function.

• `arguments` refer to the input parameters of the function, similar to traditional function definitions.

• The `if` keyword is used to introduce the conditional statement.

• `condition` represents the logical condition that is evaluated. If the condition is true, the first `expression` is executed; otherwise, the second `expression` is executed.

To better understand lambda functions, let's consider a simple example. Suppose we want to create a lambda function that returns "Even" if a given number is even, and "Odd" if it's odd. We can define the lambda function as follows:

is_even = lambda x: "Even" if x % 2 == 0 else "Odd"

In the example provided above, we have a lambda function that takes an argument x, which represents the number we want to evaluate. Within the lambda function, we have a condition x % 2 == 0 that checks whether x is divisible by 2 without leaving any remainder. If this condition evaluates to true, the lambda function returns the string "Even". However, if the condition evaluates to false, indicating that x is not divisible by 2, the lambda function returns the string "Odd". This allows us to determine whether a given number is even or odd using a concise lambda function with an if−else statement.

Now, let's see the function in action:

print(is_even(4))
print(is_even(7))

Output

Even
Odd

As you can see in the output above, the lambda function with the if−else statement correctly determines whether a number is even or odd based on the condition we provided. This concise and small form allows us to handle such simple decision−making processes effectively.

Now that we’ve understood if, and else in Python lambda functions, let’s move to the next section of this article to learn how to use multiple if else or elif in the lambda functions.

Multiple if−else conditions using Elif

In this section, we will now explore how to use multiple if−else conditions in lambda functions by incorporating `elif` statements. This enables us to handle more complex decision−making scenarios. Let's take a look at an example to understand this concept better.

Consider a lambda function that determines the grade based on a student's score. We can define the lambda function as follows:

get_grade = lambda score: "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "D" if score >= 60 else "F"

In the above example, we have employed multiple conditions using the elif statements within the lambda function. It is important to note that these conditions are evaluated sequentially, one after another. As the evaluation progresses, if a condition is found to be true, the corresponding grade is returned. However, if none of the conditions are met, the lambda function gracefully concludes by returning the value "F". This approach ensures that each condition is checked in a specific order, enabling us to handle a range of scenarios efficiently and provide accurate results based on the given conditions.

Let's see the function in action with different scores:

print(get_grade(95))
print(get_grade(85))
print(get_grade(75))
print(get_grade(65))
print(get_grade(65))

Output

A
B
C
D
E

As you can see from the output above, the lambda function correctly determines the grades based on the scores we provided. The order of evaluation is crucial here. If the first condition is true, it returns the corresponding grade and skips the remaining conditions. This sequential evaluation allows us to handle multiple scenarios effectively.

Nested if−else Conditions

In addition to multiple if−else conditions, we can also nest if−else statements within lambda functions to handle more intricate decision−making logic. Let's consider one more example to understand this concept.

Suppose we want to categorize a number into different ranges: "Positive" if it's greater than 0, "Negative" if it's less than 0, and "Zero" if it's exactly 0. We can define a lambda function with nested if−else conditions as follows:

categorize_number = lambda num: "Positive" if num > 0 else "Negative" if num < 0 else "Zero"

In this example, the lambda function checks if the number is greater than 0. If true, it returns "Positive". Otherwise, it proceeds to the nested condition and checks if the number is less than 0. If true, it returns "Negative". If none of the conditions are met, it returns "Zero".

Let's test the function with different numbers:

print(categorize_number(5))
print(categorize_number(-2))
print(categorize_number(0))

Output

Positive
Negative
Zero

As demonstrated in the output above, the lambda function with nested if−else conditions categorizes the numbers correctly based on the defined logic. This technique allows us to handle intricate decision−making scenarios efficiently.

Conclusion

In this tutorial, we have explored the versatility of Python lambda functions and learned how to incorporate if, else, and elif statements within them. By using lambda functions, we can create concise and efficient code without the need for formal function definitions. We have seen examples of using if, else, and elif statements in lambda functions, including handling multiple conditions and nesting if−else statements. These techniques allow us to handle complex decision−making scenarios in a compact and readable manner. We also provided working examples for each of the scenarios.