Python Lambda Functions Exercises

In Python, lambda functions provide a concise way to create small, anonymous functions without formally defining them using the `def` keyword. Lambda functions are especially useful for short operations that are used temporarily, such as in sorting, filtering, or mapping data.

A lambda function can take any number of arguments but contains only a single expression, which is evaluated and returned.

Consider the following code:

multiply = lambda x, y: x * y
result = multiply(5, 4)
print(result)

What does this example demonstrate about Python lambda functions?

Lambda functions can have multiple statements and return multiple values.

Lambda functions provide a quick way to create anonymous functions with a single expression.

Lambda functions are slower than regular functions and cannot be assigned to variables.

Lambda functions require the use of the def keyword to be defined.

This example shows how to create a lambda function assigned to the variable multiply, which takes two arguments x and y and returns their product.

The syntax lambda x, y: x * y defines the function anonymously in a single line.
You can call it like a regular function: multiply(5, 4) returns 20.
Lambda functions are useful for short, throwaway functions, often used as arguments to higher-order functions like map(), filter(), and sorted().

Although they are concise, lambda functions are limited to a single expression and cannot contain statements or annotations like regular functions.

Which of the following is the correct syntax for a lambda function that adds 5 to its input?

lambda x: x + 5

lambda (x): return x + 5

lambda x: return x + 5

def lambda(x): x + 5

The correct syntax for a lambda function that adds 5 to its input is lambda x: x + 5. Lambda functions do not use the return keyword — they automatically return the value of the expression.

Which of the following lambda functions multiplies two numbers?

lambda a, b: a * b

lambda (a, b): return a * b

lambda a b: a * b

The lambda function lambda a, b: a * b correctly takes two arguments and returns their product. The syntax is concise and uses only the expression after the colon.

What will be the output of this code?

double = lambda x: x * 2
print(double(4))

8

6

4

2

The lambda function takes one input and returns its value multiplied by 2. So when the input is 4, the result is 4 * 2 = 8. This simple usage showcases the typical purpose of a lambda.

Which of the following keywords is used to define a lambda function?

function

anonymous

lambda

define

The keyword lambda is used in Python to create anonymous functions. These functions are useful for short operations that can be expressed in a single line of code and are often passed as arguments to higher-order functions.

Which of the following code snippets correctly uses a lambda function to filter even numbers from a list?

list(filter(lambda x: x % 2 != 0, [1, 2, 3, 4]))

list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4]))

list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4]))

list(filter(lambda x: x > 2, [1, 2, 3, 4]))

The lambda function lambda x: x % 2 == 0 filters out even numbers by checking if the number has no remainder when divided by 2. The filter function applies this condition to each element, and list() collects the result. The output will be [2, 4].

Option 1 and 3 return odd numbers, and option 4 returns values greater than 2, not even numbers specifically.

What will be the output of the following code?

my_list = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, my_list))
print(squared)

[1, 2, 3, 4]

[2, 4, 6, 8]

[1, 4, 9, 16]

[1, 8, 27, 64]

The map function applies the lambda function lambda x: x**2 to each element of my_list. This squares every number in the list: 1², 2², 3², 4², resulting in [1, 4, 9, 16].

This is a typical use case of map with lambda to perform element-wise transformations.

Which of the following best describes the scope of variables used inside a lambda function?

They can only access global variables.

They can only access local variables from the outer function scope.

They follow the same scope resolution rules as regular functions.

They cannot access any variables outside the lambda.

Lambda functions follow Python’s LEGB (Local, Enclosing, Global, Built-in) scope resolution, the same as regular functions. They can access variables from their enclosing scope and behave similarly to nested functions in terms of variable access.

This makes them flexible and powerful in functional programming contexts like map, filter, and sorted with custom keys.

Which built-in Python function is commonly used with lambda to apply a transformation to a list?

sorted()

input()

type()

print()

Functions like sorted(), map(), and filter() are commonly used with lambda functions. Among the options given, sorted() is the correct choice since it can take a key argument which is often a lambda to customize sort behavior.

For example, you might use sorted(list_of_tuples, key=lambda x: x[1]) to sort based on the second element of each tuple.

What is the output of the following code?

items = ['apple', 'banana', 'cherry']
result = list(map(lambda x: x.upper(), items))
print(result)

['APPLE', 'BANANA', 'CHERRY']

['apple', 'banana', 'cherry']

['Apple', 'Banana', 'Cherry']

['APPLE', 'banana', 'cherry']

The lambda function passed to map() applies the upper() method to each string in the list. This converts each element to uppercase, resulting in ['APPLE', 'BANANA', 'CHERRY'].

The map function is ideal for applying a transformation to each item in a sequence, and combining it with lambda makes the transformation concise and inline.

What will be the output of the following code?

pairs = [(3, 4), (1, 2), (5, 1)]
pairs.sort(key=lambda x: x[1])
print(pairs)

[(5, 1), (1, 2), (3, 4)]

[(3, 4), (1, 2), (5, 1)]

[(1, 2), (5, 1), (3, 4)]

[(1, 2), (3, 4), (5, 1)]

The key function lambda x: x[1] tells sort() to sort the list based on the second element of each tuple. That means it compares 4, 2, and 1. So the correct sorted order is by 1, 2, 4 → [(5, 1), (1, 2), (3, 4)].

This kind of sorting is commonly used in data processing and shows how lambdas can act as dynamic keys for sorting operations.

Which of the following is True about lambda functions and closures?

Lambda functions cannot access variables outside their scope.

Lambda functions can capture and use variables from their enclosing scope.

Lambda functions cannot be used inside another function.

Lambda functions must be declared as global to work with closures.

Lambda functions support closures, meaning they can capture variables from the enclosing lexical scope. This allows them to retain and use the values of external variables even when called outside that scope.

This behavior makes lambdas useful in functional programming scenarios, such as decorators or callbacks that rely on state from an outer function.

What is the output of this code?

def outer():
    val = 10
    return lambda x: x + val

add_ten = outer()
print(add_ten(5))

5

10

15

Error

The lambda function returned by outer() has access to the variable val from its enclosing scope. When add_ten(5) is called, it computes 5 + 10 = 15.

This demonstrates how lambda functions can capture and remember values from the scope in which they were created, a feature known as lexical closure.

Which of the following would sort a list of strings by their last character using a lambda function?

sorted(strings, key=lambda x: x[0])

sorted(strings, key=lambda x: x[-1])

sorted(strings, lambda x: x[-1])

sort(strings, key=lambda x[-1])

The correct approach to sort by the last character of each string is sorted(strings, key=lambda x: x[-1]). This lambda takes each string x and returns its last character, which becomes the sorting key.

Option 1 sorts by the first character, option 3 has incorrect syntax, and option 4 misuses the lambda syntax. Option 2 is the only valid and correct method.

Which of the following is not a valid use case for lambda functions?

As a key function in sorting

As an argument to map()

As a quick callback function

As a standalone function with complex logic and multiple lines

Lambda functions are restricted to a single expression and cannot contain multiple statements or complex control flow like loops and conditionals. Therefore, using them for complex logic is not appropriate.

They are best suited for short, simple operations, especially as arguments to higher-order functions like map(), filter(), and sorted().

What will be the output of this code snippet?

funcs = [lambda x, i=i: x + i for i in range(3)]
print([f(10) for f in funcs])

[13, 13, 13]

[10, 11, 12]

[11, 12, 13]

[10, 10, 10]

This code creates a list of lambda functions where each lambda captures a unique value of i due to the use of i=i as a default argument. Without it, all lambdas would capture the final value of i.

Each lambda returns x + i. So the final output is: [10+0, 10+1, 10+2] → [10, 11, 12]. This is a common trick to avoid late binding in lambdas inside loops.

Which of the following lambda expressions returns the sum of squares of two numbers?

lambda x, y: x + y

lambda x, y: (x + y) ** 2

lambda x, y: x**2 + y**2

lambda x, y: x * y

The expression lambda x, y: x**2 + y**2 computes the square of both x and y and then sums them. That matches the requirement of "sum of squares."

Option 2 gives the square of the sum, which is a different operation mathematically. Understanding this distinction is crucial in numeric lambda usage.

Choose the lambda that returns True if a number is divisible by both 3 and 5.

lambda x: x % 3 == 0 or x % 5 == 0

lambda x: x % 3 == 0 and x % 5 == 0

lambda x: x % 15 != 0

lambda x: x % 5 == 3 and x % 3 == 0

To check if a number is divisible by both 3 and 5, we need to ensure both conditions are satisfied. The expression x % 3 == 0 and x % 5 == 0 correctly does that.

Option 1 uses or, which is incorrect. Option 3 returns True for non-divisible values. Option 4 is nonsensical for this use case.

What is the result of this code?

data = [5, 10, 15]
func = lambda l: [x * 2 for x in l if x > 5]
print(func(data))

[10, 20, 30]

[20, 30]

[5, 10, 15]

[10, 20]

The lambda filters the input list to include only numbers greater than 5: [10, 15]. Then it doubles each of those: [10*2, 15*2] → [20, 30]. So the result is [20, 30].

This question tests list comprehension embedded inside a lambda, which is a powerful one-liner expression pattern in Python.

Which statement is true regarding the use of `lambda` with `filter()`?

Lambda inside filter must return a string

Filter applies lambda to each pair of items in the list

Lambda in filter must return True or False

Filter ignores lambda and only checks None values

The filter() function applies the lambda to each item and includes only those for which the lambda returns True. So the lambda must evaluate to a boolean result.

This behavior makes filter useful for cleaning or extracting elements from lists based on conditions. Misunderstanding the expected return type often leads to bugs.

Python Lambda Functions Exercises

In Python, lambda functions provide a concise way to create small, anonymous functions without formally defining them using the def keyword. Lambda functions are especially useful for short operations that are used temporarily, such as in sorting, filtering, or mapping data.

A lambda function can take any number of arguments but contains only a single expression, which is evaluated and returned.

Consider the following code:

What does this example demonstrate about Python lambda functions?

Which of the following is the correct syntax for a lambda function that adds 5 to its input?

Which of the following lambda functions multiplies two numbers?

What will be the output of this code?

Which of the following keywords is used to define a lambda function?

Which of the following code snippets correctly uses a lambda function to filter even numbers from a list?

What will be the output of the following code?

Which of the following best describes the scope of variables used inside a lambda function?

Which built-in Python function is commonly used with lambda to apply a transformation to a list?

What is the output of the following code?

What will be the output of the following code?

Which of the following is True about lambda functions and closures?

What is the output of this code?

Which of the following would sort a list of strings by their last character using a lambda function?

Which of the following is not a valid use case for lambda functions?

What will be the output of this code snippet?

Which of the following lambda expressions returns the sum of squares of two numbers?

Choose the lambda that returns True if a number is divisible by both 3 and 5.

What is the result of this code?

Which statement is true regarding the use of lambda with filter()?

About This Exercise: Python – Lambda Functions

In Python, lambda functions provide a concise way to create small, anonymous functions without formally defining them using the `def` keyword. Lambda functions are especially useful for short operations that are used temporarily, such as in sorting, filtering, or mapping data.

Which statement is true regarding the use of `lambda` with `filter()`?