Guide to Lambda with Multiple Lines in Python

Lambda functions in Python are often hailed for their simplicity and conciseness, allowing developers to create anonymous functions quickly. However, traditional lambda functions are limited to a single expression. What if you need more complex functionality within a lambda function, spanning multiple lines of code? In this guide, we'll delve into techniques for achieving just that, enabling you to leverage the power of lambda expressions while accommodating more extensive operations. Let's explore how to create multi-line lambda functions in Python.

What is lambda

In Python, a lambda function is a small anonymous function defined using the lambda keyword. Lambda functions can take any number of arguments but can only have one expression. They are particularly useful when you need a simple function for a short period and don't want to formally define a function using the def keyword.

Traditional lambda functions in Python are restricted to a single line of code, which limits their utility for more complex operations. However, they can still be quite powerful for tasks such as mapping and filtering data or creating simple callbacks.

Here's a basic syntax of a lambda function:

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

How to use lambda in multiple lines

To use a lambda function spanning multiple lines, you can encapsulate multiple expressions within a list. Each expression within this list becomes an element, and the lambda function simply returns that list. Consider this example:

random_list = [0, 1, 2, 3, 4, 5]
add = lambda x, y: x + y
subtract = lambda x, y: x - y
function = lambda: [add(1, 2), subtract(5, 4), random_list.pop(2), random_list]
print(function())  # Output: [3, 1, 2, [0, 1, 3, 4, 5]]

In this example, the lambda function function encapsulates three expressions within a list:

  • add(1, 2), which adds 1 and 2.
  • subtract(5, 4), which subtracts 4 from 5.
  • random_list.pop(2), which removes and returns the element at index 2 from random_list.

When you call function(), it executes these expressions in the order defined and returns the resulting list [3, 1, 2]. It's worth noting that the fourth element of the list contains the modified random_list.


In conclusion, while Python's lambda functions are typically used for simple, single-line expressions, it's possible to utilize them for more complex operations across multiple lines. By encapsulating multiple expressions within a list and returning that list from the lambda function, you can achieve this multi-line functionality. However, it's essential to maintain readability and consider whether a regular named function might be more appropriate for complex logic. Understanding the flexibility of lambda functions enables Python programmers to leverage them effectively in various scenarios, enhancing code organization and succinctness when appropriate.