Python Lambda

15 Min Read
15 Views

Unleash the power of Python lambda functions! These tiny expressions, also known as anonymous functions, allow you to define simple functions within a single line of code. This makes them ideal for short, throwaway functions in larger expressions or callback functions. For instance, you can use lambda functions to sort lists based on specific criteria, filter data sets according to a condition, or perform basic mathematical operations on the fly. By incorporating lambda functions effectively, you can enhance the readability and compactness of your Python code.

Python-Lambda-Function
Table of Contents

Python Lambda Function

Python lambda functions, known as anonymous functions, are a handy way to define small, one-line functions without needing a formal def keyword and function name. They’re typically used for short, self-contained expressions that you might only use once or in specific contexts.

Python Lambda Function Syntax

function_object = lambda arguments: expression

  • function_object: This variable will hold the lambda function you create.
  • lambda: Keyword to define a lambda function.
  • arguments: The function can accept a comma-separated list of arguments (optional).
  • expression: The calculation or logic you want the function to perform. The lambda function returns this expression.

Python Lambda Function Example

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

Explanation

  • Line 1: Defines a lambda function named add that takes two arguments x and y and returns their sum using the expression x + y.
  • Line 2: Calls the add function with arguments 5 and 3, storing the returned value (8) in the variable result.
  • Line 3: Prints the result of the lambda function call (8).

Simple Calculations with Python Lambda Functions

Here’s how you can perform simple arithmetic using lambda functions in Python:

Syntax

function_name = lambda arguments: expression

  • function_name (optional): You can optionally assign a name to your lambda function, but it’s not mandatory for simple use cases.
  • arguments: Comma-separated list of variables that the lambda function will accept as input.
  • expression: The calculation or operation you want to perform on the arguments. This will be returned as the output.

Example: Adding Two Numbers

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

Explanation

  • Line 1: Defines a lambda function that takes two arguments x and y and returns their sum using the + operator. We assign this function to a variable named add_numbers for readability, but this is optional.
  • Line 2: Calls the lambda function (or the assigned variable) and provides the values 5 and 3 as arguments. These arguments are assigned to x and y within the lambda function.
  • Line 3: Prints the calculation result, which is 8 (5 + 3).

Using Python Lambda Functions as Arguments

Lambda functions in Python can be powerful when used as arguments to other functions. This allows you to pass small, anonymous functions tailored to your needs.

Syntax

higher_order_function(lambda arguments: expression)

  • higher_order_function: This is a function that can take other functions as arguments.
  • lambda arguments: expression: The lambda function you created contains the logic you want to execute.

Example: Sorting Numbers by Absolute Value

numbers = [3, -1, 4, -2]
sorted_numbers = sorted(numbers, key=lambda x: abs(x))
print(sorted_numbers)  # Output: [-1, -2, 3, 4]

Explanation

  • Line 1: Creates a list numbers with some integer values.
  • Line 2: Uses the built-in sorted() function to sort the numbers. The key argument is used to specify a custom sorting order. In this case, we pass a lambda function that takes a number x as input and returns its absolute value abs(x). This will sort the numbers based on their distance from zero (absolute value).
  • Line 3: Prints the sorted list sorted_numbers, showing the numbers ordered by their absolute value, with negative numbers coming first.

Sorting with Python Lambda Functions and sorted()

Python’s sorted() function becomes even more powerful when combined with lambda functions. Lambdas allow you to define short, custom sorting criteria on the fly.

Syntax

sorted_list = sorted(iterable, key=lambda element: expression)

  • sorted_list: The variable that will store the new sorted list.
  • sorted(): The built-in sorted() function for sorting an iterable (like a list).
  • iterable: The list or collection you want to sort.
  • key: An optional argument that specifies a sorting rule.
  • lambda element: expression: The lambda function defining the sorting criteria.
    • element: This argument represents each item in the iterable being sorted.
    • expression: The calculation or comparison you want to perform on the element to determine the sort order.

Example: Sorting Strings by Length

words = ["apple", "banana", "watermelon", "grape"]
sorted_by_length = sorted(words, key=lambda word: len(word))
print(sorted_by_length)  # Output: ['apple', 'grape', 'banana', 'watermelon']

Explanation

  • Line 1: Creates a list words containing some fruits.
  • Line 2: Uses sorted() to sort the words list. The key argument is used with a lambda function. The lambda function takes a word (word) as input and returns its length (len(word)). This tells sorted() to sort the words based on their length.
  • Line 3: Prints the sorted_by_length list, showing the words ordered by their character count (shortest to longest).

Python List Comprehension with Lambda Functions

Here’s how Python lambda functions can be combined with list comprehensions to create concise and readable code:

Syntax

new_list = [expression(element) for element in iterable]

  • new_list: The variable that will store the newly created list.
  • [ ]: The list comprehension brackets.
  • expression(element): The operation or calculation to perform on each element in the iterable. This can include a lambda function.
  • for element in iterable: Iterates over the elements in the original iterable (like a list).

Example: Squaring Numbers with List Comprehension and Lambda

numbers = [1, 2, 3, 4]
squares = [num * num for num in numbers]  # Traditional list comprehension for squaring
squares_lambda = [lambda x: x * x(num) for num in numbers]  # Using lambda inside list comprehension

print(squares)  # Output: [1, 4, 9, 16]
print(squares_lambda)  # Output: [<function __main__.<lambda(x=num): x * x(num=1)>, ...] (List of lambda functions)

Explanation

  • Line 1: Creates a list numbers with some numbers.
  • Line 2: Shows a traditional list comprehension. It iterates over numbers and squares each element using num * num and stores the results in squares.
  • Line 3: Demonstrates a list comprehension using a lambda function. It iterates over numbers, but instead of directly squaring, it creates a lambda function lambda x: x * x(num). This lambda squares the input x but retains the value of num from the loop iteration. The lambdas themselves are stored in squares_lambda.
  • Line 5: Prints the squares list, showing the squared numbers (same output as the traditional approach).
  • Line 6: Prints the squares_lambda list. This contains a list of lambda functions, each holding the squared value of its corresponding element from the original numbers list.

Conditional Logic in Python Lambda Functions (if-else)

Lambda functions in Python can even incorporate conditional logic using if-else statements. This allows you to create short, dynamic functions that adapt their output based on certain conditions.

Syntax

function_name = lambda arguments: expression_if_true if condition else expression_if_false

  • arguments: The lambda function will accept a comma-separated list of variables as input.
  • expression_if_true: The value to return if the condition is True.
  • condition: The logical expression that determines which outcome to return.
  • expression_if_false: The value to return if the condition is False.

Example: Classifying Numbers as Even or Odd

categorize_number = lambda num: "Even" if num % 2 == 0 else "Odd"  # Lambda with if-else
result1 = categorize_number(8)   # Pass an even number
result2 = categorize_number(5)   # Pass an odd number
print(result1)  # Output: Even
print(result2)  # Output: Odd

Explanation

  • Line 1: Defines a lambda function named categorize_number that takes one argument num. It uses an if-else statement to check if num is even using the modulo operator (%). If even (num % 2 == 0), it returns “Even”; otherwise, it returns “Odd”.
  • Line 2: Calls the lambda function with the argument 8 (an even number) and stores the result in result1.
  • Line 3: Calls the lambda function again with the argument 5 (an odd number) and stores the result in result2.
  • Line 4: Prints the value in result1, which is “Even” since 8 is even.
  • Line 5: Prints the value in result2, which is “Odd” since 5 is odd.

Filtering with Python Lambda Functions and filter()

Leverage lambda functions with filter() function in Python to streamline filtering operations. Lambdas can act as compact filters within filter(), allowing you to express your filtering criteria concisely.

Syntax

filtered_elements = filter(lambda element: condition, iterable)

  • filtered_elements: The variable that will store the new list containing the filtered elements.
  • filter(): The built-in filter() function is used to filter iterable (like lists).
  • lambda element: condition: The lambda function defining the filtering criteria.
    • element: This argument represents each element in the iterable being filtered.
    • condition: The expression that determines whether to keep the element (True) or discard it (False).
  • iterable: The list or collection you want to filter.

Example: Filtering Positive Numbers

numbers = [-3, 1, 0, 4, -2]
positive_numbers = list(filter(lambda num: num > 0, numbers))  # Use lambda with filter()
print(positive_numbers)  # Output: [1, 4]

Explanation

  • Line 1: Creates a list numbers with positive, negative, and zero values.
  • Line 2: Uses filter() to create a new list positive_numbers. It applies a lambda function that takes a number (num) as input and checks if it’s greater than zero (num > 0). If True, the number is kept; otherwise, it’s discarded. The list() function converts the filter object to a regular list.
  • Line 3: Prints the positive_numbers list, showing only the positive values (1 and 4).

Data Transformation with Python Lambda Functions and map()

Python’s map() function can be a powerful tool for transforming elements in a collection. You can create concise transformations on the fly when paired with lambda functions.

Syntax

transformed_list = list(map(lambda element: expression, iterable))

  • transformed_list: The variable that will store the new list containing the transformed elements.
  • map(): The built-in map() function is used to apply a function to all elements in an iterable (like a list).
  • lambda element: expression: The lambda function defining the transformation to apply.
    • element: This argument represents each element in the iterable being transformed.
    • expression: The calculation or operation you want to perform on the element.
  • iterable: The list or collection you want to transform.

Example: Converting Strings to Uppercase

words = ["apple", "banana", "cherry"]
uppercase_words = list(map(lambda word: word.upper(), words))  # Use lambda with map()
print(uppercase_words)  # Output: ['APPLE', 'BANANA', 'CHERRY']

Explanation

  • Line 1: Creates a list words containing some fruits in lowercase.
  • Line 2: Uses map() to create a new list uppercase_words. It applies a lambda function that takes a word (word) as input and uses the .upper() method to convert it to uppercase. The list() function converts the map object to a regular list.
  • Line 3: Prints the uppercase_words list, showing all the fruits in uppercase letters.

Aggregation with Python Lambda Functions and reduce()

Lambdas can be used with Python’s reduce() function for concise calculations that accumulate results over multiple elements in a sequence.

Syntax

reduced_value = reduce(lambda element1, element2: expression, iterable, initial_value (optional))

  • reduced_value: The variable that will store the final reduced value.
  • reduce(): The built-in reduce() function accumulates a value based on an operation.
  • lambda element1, element2: expression: The function defining the reduction operation.
    • element1: Represents the first element in the current iteration.
    • element2: Represents the second element in the current iteration (and subsequent elements in future iterations).
    • expression: The calculation that combines these elements.
  • iterable: The list or collection you want to reduce.
  • initial_value (optional): An optional starting value for the accumulation (defaults to the first element in the iterable if not provided).

Note: In Python 3, reduce is no longer a built-in function. You can use it from the functools module or achieve similar functionality with list comprehensions or loops.

Example: Finding the Sum of Squares

from functools import reduce  # Import reduce from functools
numbers = [2, 3, 4]
sum_of_squares = reduce(lambda x, y: x + y**2, numbers, 0)
print(sum_of_squares)  # Output: 29 (2^2 + 3^2 + 4^2)

Explanation

  • Line 1: Imports the reduce function from the functools module (necessary in Python 3).
  • Line 2: Creates a list numbers with some numbers.
  • Line 3: Uses reduce() with a lambda function. The lambda function takes two arguments: x (accumulator) and y (current element). It squares y using y**2 and adds it to the accumulator x. The reduce() function starts with the optional initial_value of 0 and iteratively applies the lambda function, accumulating the sum of squares.
  • Line 4: Prints the sum_of_squares, which is 29 (2 squared plus 3 squared plus 4 squared).

Python Lambda Functions vs. Regular Functions: Key Differences

Here’s a breakdown of the key differences between Python lambda functions and regular functions:

Regular Functions

  • Definition: Use the def keyword followed by a function name, parentheses for arguments, and a colon. Then, you add indented code within the function body.
  • Flexibility: Can be complex and multi-line, containing statements, loops, conditional logic, and function calls.
  • Readability: Well-suited for longer, well-defined tasks with descriptive names.

Lambda Functions

  • Definition: Use the lambda keyword followed by arguments in parentheses and a colon, then a single expression that returns the output.
  • Conciseness: Designed for short, compact expressions, typically limited to a single line of code.
  • Readability: Can become cryptic for complex logic, often best for simple operations within other functions.

Example: Adding Numbers

Regular Function

def add_numbers(x, y):
    """Adds two numbers and returns the sum."""  # Docstring for clarity (optional)
    return x + y
result = add_numbers(5, 3)  # Call the function
print(result)  # Output: 8

Lambda Function

add_numbers = lambda x, y: x + y  # Lambda function
result = add_numbers(5, 3)  # Call the lambda function directly
print(result)  # Output: 8

Explanation

  • Line 1: Defines a regular function named add_numbers using def.
  • Line 2 (Optional): Adds a docstring to explain the function’s purpose.
  • Line 3: The function body with an indented return statement to add x and y.
  • Line 4: Calls the add_numbers function with arguments and stores the result.
  • Line 5: Prints the sum (8).
  • Line 6: Defines a lambda function directly and assigns it to a variable add_numbers.
  • Line 7: Calls the lambda function like a regular function with arguments.
  • Line 8: Prints the sum (8), the same as the regular function approach.

The Single Expression Requirement

A key characteristic of Python lambda functions is that they are limited to single expressions. This means they can perform a concise calculation or operation and return the result but cannot contain multiple statements like regular functions.

Syntax

function_name = lambda arguments: expression

Example: Multiplying Numbers

multiply = lambda x, y: x * y
product = multiply(4, 3)
print(product)  # Output: 12

Explanation

  • Line 1: Defines a lambda function named multiply that takes two arguments x and y. The expression x * y performs the multiplication and is returned as the output.
  • Line 2: Calls the multiply lambda function with the values 4 and 3, storing the result in product.
  • Line 3: Prints the product, which is 12 (4 multiplied by 3).

Restrictions on Assignments

Unlike regular functions, Python lambda functions cannot include assignment statements within their definition. You can’t use them to set variables or perform actions that modify the program state. Lambdas focus solely on a single expression that produces a result.

Regular Statements Not Allowed in Lambda Functions

Lambda functions in Python are limited to a single expression. This means they cannot include the typical statements you’d find in regular functions, like if statements, loops (like for or while), or variable assignments. Lambdas focuses purely on calculations or transformations and returns the resulting value.

Limited Scope for Exception Handling

While lambda functions in Python are powerful for concise expressions, they have limitations regarding error handling. Lambdas themselves cannot handle exceptions within their definition.

  • Lambdas cannot use try-except blocks to catch and manage errors.
  • Errors that occur during lambda execution will propagate to the calling code.

Example: Potential Division by Zero

divide = lambda x, y: x / y  # Lambda for division (no error handling)
result = divide(10, 0)  # Attempt division by zero
print(result)  # This will cause a ZeroDivisionError

Explanation

  • Line 1: Defines a lambda function divide that takes two arguments x and y and performs division. There’s no way to handle potential errors within the lambda itself.
  • Line 2: Calls the divide lambda function with 10 and 0 (division by zero).
  • Line 3: This line will cause a ZeroDivisionError since you cannot divide by zero. The lambda does not handle the error and will bubble up to the calling code. You need to handle this error in the lambda function code.

Also On CodeTidBits