# Python Lambda Function

Lambda functions, commonly referred to as “anonymous functions,” are one of Python’s most unique and powerful features. These functions provide a concise way to create simple functions, offering both clarity and a reduction in code size. This article will provide a comprehensive overview of lambda functions in Python, diving into their creation, use-cases, advantages, and limitations.

### Introduction to Lambda Functions

In Python, a lambda function is a small, anonymous function defined using the lambda keyword. Unlike regular functions declared using the def keyword, lambda functions don’t have a name.

#### Basic Syntax

The general syntax of a lambda function is:

lambda arguments: expression

The expression is executed and returned when the lambda function is called. A lambda function can have multiple arguments but only one expression.

### Simple Examples

#### Basic Lambda

A function that adds two numbers:

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

#### Lambda with One Argument

Determining if a number is even:

is_even = lambda x: x % 2 == 0
print(is_even(4))  # Output: True

### Characteristics of Lambda Functions

• Anonymous: They don’t have a name and are often used for short-lived purposes.
• Single Expression: Only one expression can be used, which is returned.
• Inline: They are often used where functions are expected, like in arguments.

### Lambda Functions vs. Regular Functions

To better understand lambda functions, let’s compare them to regular functions:

Regular Function:

def square(x):
return x * x

Equivalent Lambda Function:

square = lambda x: x * x

While the results are the same, lambda functions are more concise.

### Using Lambda Function with if-else

Lambda functions in Python, despite their simplicity, can incorporate conditional logic with the help of the if-else construct. This makes lambda functions more versatile and suitable for a broader range of applications.

#### Basic Syntax

The syntax for incorporating if-else within a lambda function is as follows:

lambda arguments: returned_value_if_true if condition else returned_value_if_false

#### Simple Examples

Check for Even or Odd:

Here’s a lambda function that checks if a number is even or odd:

is_even = lambda x: "Even" if x % 2 == 0 else "Odd"
print(is_even(4))  # Output: Even
print(is_even(5))  # Output: Odd

Determine Maximum of Two Values:

This lambda function returns the maximum of two numbers:

maximum = lambda x, y: x if x > y else y
print(maximum(10, 20))  # Output: 20

### Using Lambda Function with map()

The map() function applies a given function to all items in the input list. It’s commonly used with lambda functions:

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

### Using Lambda Function with filter()

filter() extracts elements from a list for which a function returns True. Here’s an example that filters out even numbers:

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

### Using Lambda Function with sorted Function

You can use lambda functions for custom sorting:

pairs = [(1, 3), (2, 2), (4, 1)]
sorted_pairs = sorted(pairs, key=lambda pair: pair)
print(sorted_pairs)  # Output: [(4, 1), (2, 2), (1, 3)]

• Conciseness: Reduces the size of the code for simple functions.
• Inline Creation: Can be defined right where they are used, often improving readability.
• Functional Approach: Facilitates a functional programming style.

### Limitations

• Simplicity: Designed for simple tasks. Complex operations should be left for regular functions.