October 15, 2024

Python Tutorials

Python Lambda Functions

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

  • lambda: The keyword used to define a lambda function.
  • arguments: A comma-separated list of parameters (similar to function arguments).
  • expression: A single expression that is evaluated and returned.

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()

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()

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()

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()

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

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.

You May Like