### Python Lambda Functions

Lambda functions in Python are small, anonymous functions that are defined using the `lambda`

keyword. They can have any number of input parameters but can only contain a single expression. Lambda functions are often used when you need a simple function for a short period and don’t want to formally define it using the `def`

keyword.

**1. Syntax of Lambda Functions**

The syntax of a lambda function is:

`lambda arguments: expression`

: The keyword used to define a lambda function.`lambda`

: A comma-separated list of parameters (similar to function arguments).`arguments`

: A single expression that is evaluated and returned.`expression`

**2. Example of a Lambda Function**

Here’s a basic example of a lambda function that adds two numbers:

```
# A lambda function to add two numbers
add = lambda x, y: x + y
# Using the lambda function
result = add(3, 5)
print(result) # Output: 8
```

In this example, `lambda x, y: x + y`

is a lambda function that takes two arguments (`x`

and `y`

) and returns their sum. The lambda function is assigned to the variable `add`

, which can then be called like a regular function.

**3. Using Lambda Functions with Built-in Functions**

Lambda functions are commonly used with Python’s built-in functions like `map()`

, `filter()`

, and `sorted()`

.

**a. Using **`lambda`

with `map()`

`lambda`

with `map()`

The `map()`

function applies a given function to all the items in an iterable (like a list) and returns an iterator.

```
# List of numbers
numbers = [1, 2, 3, 4, 5]
# Using lambda with map to square each number
squared = map(lambda x: x ** 2, numbers)
print(list(squared)) # Output: [1, 4, 9, 16, 25]
```

**b. Using **`lambda`

with `filter()`

`lambda`

with `filter()`

The `filter()`

function filters elements from an iterable based on a function that returns `True`

or `False`

.

```
# List of numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Using lambda with filter to get even numbers
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens)) # Output: [2, 4, 6, 8, 10]
```

**c. Using **`lambda`

with `sorted()`

`lambda`

with `sorted()`

The `sorted()`

function sorts an iterable based on a specified key.

```
# List of tuples
points = [(2, 3), (1, 4), (3, 1), (0, 0)]
# Using lambda with sorted to sort by the second element of each tuple
sorted_points = sorted(points, key=lambda point: point[1])
print(sorted_points) # Output: [(0, 0), (3, 1), (2, 3), (1, 4)]
```

**4. Using Lambda Functions with **`reduce()`

`reduce()`

The `reduce()`

function (from the `functools`

module) applies a rolling computation to sequential pairs of values in an iterable.

```
from functools import reduce
# List of numbers
numbers = [1, 2, 3, 4, 5]
# Using lambda with reduce to compute the product of all numbers
product = reduce(lambda x, y: x * y, numbers)
print(product) # Output: 120
```

**5. Lambda Functions as Inline Functions**

Lambda functions are often used inline, where they are defined and used immediately, such as in sorting or filtering data.

**a. Sorting a List of Dictionaries**

```
students = [
{"name": "Alice", "grade": 88},
{"name": "Bob", "grade": 75},
{"name": "Charlie", "grade": 95}
]
# Sort students by grade using a lambda function
sorted_students = sorted(students, key=lambda student: student["grade"])
print(sorted_students)
# Output: [{'name': 'Bob', 'grade': 75}, {'name': 'Alice', 'grade': 88}, {'name': 'Charlie', 'grade': 95}]
```

**6. Limitations of Lambda Functions**

Lambda functions have some limitations compared to regular functions:

**Single Expression**: Lambda functions can only contain one expression, which limits their complexity.**Lack of Documentation**: Since lambda functions are anonymous and usually not assigned a name, they lack a docstring, making them less self-explanatory.**No Statements**: Lambda functions cannot contain statements like`return`

,`pass`

,`assert`

, or`raise`

.

**7. Lambda Functions in Higher-Order Functions**

Lambda functions are commonly used as arguments to higher-order functions—functions that take other functions as arguments.

**a. Using **`lambda`

in a Higher-Order Function

`lambda`

in a Higher-Order Function```
def apply_function(f, value):
return f(value)
# Using a lambda function to square a number
result = apply_function(lambda x: x ** 2, 5)
print(result) # Output: 25
```

**8. Lambda Functions vs. Regular Functions**

While lambda functions are concise, they are not a replacement for regular functions defined with `def`

. Use lambda functions when:

- You need a simple, one-time-use function.
- You want to pass a small function as an argument to another function (like in
`map`

,`filter`

,`sorted`

).

Use regular functions (`def`

) when:

- The function has multiple expressions.
- The function is complex and requires a name for better readability.
- You need to add documentation (docstrings) to explain the function’s purpose.

**Conclusion**

Lambda functions are a powerful feature in Python, allowing you to create small, anonymous functions on the fly. They are especially useful for short, simple operations where a full function definition would be overkill. However, because of their limitations, lambda functions should be used judiciously and in contexts where their brevity provides clear benefits. For more complex logic, stick with regular functions defined using `def`

.