In Python, anonymous functions are created using the lambda keyword. These lightweight functions can take any number of arguments but are limited to a single expression whose result is automatically returned. Because they lack a name, lambda functions cannot be defined using the def statement and are typically used inline where a function object is needed.

Lambda expressions are commonly paired with higher-order functions—functions that accept other funcsions as arguments or return them—as seen in built-in tools like map(), filter(), and sorted().

1. Defining Lambda Expressions

A basic example of a lambda function that takes two inputs and returns their sum:

add_values = lambda a, b: a + b
print(add_values(7, 2))  # Output: 9

2. Using map() with Lambda

The map() function applies a given function to each item in an iterable and returns an iterator of the results. It accepts a function and one or more iterables.

Example: Squaring each number in a range using map() and a lambda:

squared_nums = map(lambda n: n ** 2, range(5))
print(list(squared_nums))  # Output: [0, 1, 4, 9, 16]

3. Sorting with Custom Keys Using sorted()

The sorted() function returns a new list containing all items from the input iterable in ascending order by default. It supports optional parameters such as key (a function to extract comparison values) and reverse (to sort in descending order).

Basic sorting:

unsorted_list = [8, 3, 1, 6, 4]
sorted_list = sorted(unsorted_list)
print(sorted_list)  # Output: [1, 3, 4, 6, 8]

Case-insensitive string sorting:

fruits = ['grape', 'Apple', 'kiwi', 'banana']
sorted_fruits = sorted(fruits, key=str.lower)
print(sorted_fruits)  # Output: ['Apple', 'banana', 'grape', 'kiwi']

Descending order:

descending_order = sorted(unsorted_list, reverse=True)
print(descending_order)  # Output: [8, 6, 4, 3, 1]

Note that sorted() does not modify the original sequence; it always returns a new list.

While lambda functions provide a compact way to define simple logic on the fly, they should be avoided for complex operations. For clarity and maintainability, regular named functions defined with def are preferred when the logic grows beyond a single line.