In Python, a lambda function is a concise way to define a small anonymous function. It is mostly used for simple tasks or in situations where defining a named function would be cumbersome. Lambda functions are defined using the keyword “lambda” followed by the parameters in parentheses and a colon, and then the expression to be evaluated. When the lambda function is called, the value of the expression is returned. In Python, the scope of lambda functions is restricted to the line they are defined on. However, by using the backslash, you can create a multiline lambda function in Python.
A multiline lambda function allows you to define a function that spans multiple lines. This is useful when you need more than one expression to be evaluated in the function. To create a multiline lambda function, you need to use the backslash “\” to indicate that the function continues on the next line. Here is an example:
multi_line = lambda x, y, z: \
(x + y + z) ** 2 + \
(x  y  z) ** 2
In this example, we define a function “multi_line” that takes three parameters and returns the sum of two expressions. The first expression is (x + y + z) ** 2 and the second expression is (x – y – z) ** 2. The backslash “\” is used to indicate that the function continues on the next line.
Here’s another example:
add_three_numbers = lambda x, y, z: \
x + y + z
In this example, we define a function “add_three_numbers” that takes three parameters and returns the sum of the three numbers. The backslash “\” is used to indicate that the function continues on the next line.
Now that you know how to create a multiline lambda function, let’s look at an example that combines both the single line and multiline lambda functions:
lambda_function = lambda x: x * 2 if x % 2 == 0 else \
(x + 1) * 2
In this example, we define a function “lambda_function” that takes one parameter and returns a value based on a condition. If the parameter is even, the function returns the result of the expression x * 2. If the parameter is odd, the function returns the result of the expression (x + 1) * 2. The backslash “\” is used to indicate that the function continues on the next line.
Now let’s try another example of a multiline lambda function. We can define a function that takes a list of integers and returns the sum of all of the even numbers.
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_sum = lambda lst: \
sum(x for x in lst if x % 2 == 0)
print(even_sum(my_list))
In this example, we define a function “even_sum” that takes a list as a parameter and returns the sum of all even numbers in the list. The backslash “\” is used to indicate that the function continues on the next line. We use a generator expression to iterate over the list and sum up all the even numbers in the list using the “sum” function.
In conclusion, we have seen that by using the backslash “\” in Python, you can create a multiline lambda function that allows you to define a function spanning multiple lines. This comes in handy when you need to define a function with multiple expressions. Lambda functions can be used in a variety of scenarios, including filtering lists, mapping, and reducing. The examples we saw above show how to use a multiline lambda function in different scenarios, and we hope you can now use this technique in your code as well. Happy coding!
Lambda functions in Python are a powerful tool that can simplify your code and make it easier to read and understand. They provide an anonymous function definition which doesn't require a name and can be defined in one line. In Python, a lambda function is defined using the lambda keyword, followed by arguments, a colon, and then a single expression.
For example, the below lambda function takes two arguments and returns their sum:
add = lambda x, y: x+y
The same lambda function can be written with def statement as below:
def add(x, y):
return x+y
One of the main benefits of using a lambda function instead of a regular function is that you can define a simple function definition right where it's needed, such as in a list comprehension, map, or filter function. A lambda function is small and efficient, and it can avoid the overhead of creating a full function definition.
my_list = [1, 2, 3, 4, 5, 6]
list(map(lambda x: x * 2, my_list))
In the above code, the lambda function passed to the map function multiplies each number in the list by two.
Now, let's dive deeper into the multiline lambda function in Python. A lambda function can span multiple lines using a backslash "" character. This also allows us to add more complex expressions to the lambda function.
Suppose we have a list of numbers and we want to filter out the numbers which are divisible by two but less than 10. We can write this using a multiline lambda function as shown below:
my_list = [1, 2, 5, 8, 10, 12, 15]
even_numbers_below_10 = list(filter(
lambda x: \
(x % 2 == 0) and \
(x < 10),
my_list))
print(even_numbers_below_10)
In this example, the filter function is used to filter out even numbers less than 10. The lambda function uses the “and” operator and the backslash character to span multiple lines and to group multiple conditions.
We can also use multiline lambda functions for more complex expressions. Suppose we have a list of tuples containing the name and age of a person, and we want to sort the list by age. We can do this using a multiline lambda function with a key parameter as shown below:
my_list = [('Alice', 25), ('Bob', 32), ('Charlie', 18), ('David', 46)]
sorted_list = sorted(my_list,
key=lambda x: (
x[1],
x[0].lower()))
print(sorted_list)
In this example, we use the sorted function to sort the list of tuples by the second element of each tuple (the age), and then by the first element of each tuple (the name). The lambda function defines the key parameter to be the tuple with two values for sorting.
In conclusion, multiline lambda functions provide a more versatile way of defining simple anonymous functions in Python. They allow us to define functions spanning multiple lines and add more complex expressions to the lambda function. Multiline lambda functions are a powerful tool that can simplify your code, make it more readable, and reduce the overhead of defining a full function, especially when used in conjunction with list comprehensions, map functions, or filter functions.
Popular questions

What is a lambda function in Python?
Answer: A lambda function is a small anonymous function in Python that can be defined using the lambda keyword. It takes arguments, followed by a colon, and then a single expression. 
What is a multiline lambda function?
Answer: A multiline lambda function is a way to span multiple lines in a Python lambda function using a backslash. 
Why would you use a multiline lambda function?
Answer: A multiline lambda function allows you to write more complex expressions and functions that span multiple lines in a concise manner. 
Can you give an example of a multiline lambda function in Python?
Answer: Here's an example of a multiline lambda function that filters a list of integers for even numbers less than 10:
even_numbers = filter(
lambda x: \
(x % 2 == 0) and \
(x < 10),
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
)
 How do you combine multiline and singleline lambda functions in Python?
Answer: Here's an example of a lambda function that uses both multiline and singleline syntax to sort a list of tuples by age and then by name:
my_list = [('Alice', 25), ('Bob', 32), ('Charlie', 18), ('David', 46)]
sorted_list = sorted(
my_list,
key=lambda x: (x[1], x[0].lower())
)
print(sorted_list)
Tag
Lambda_syntax