Introduction

In this chapter, we will explore Lambda Expressions in Python. Lambda expressions are a concise way to create anonymous functions, which are sometimes referred to as “inline” or “unnamed” functions. Unlike regular functions created using the def keyword, lambda functions do not have a name and are often used for short, one-off operations. In this chapter, we will delve into the syntax of lambda expressions, their use cases, and limitations.

What Are Lambda Expressions?

Lambda expressions are a way to define small, unnamed functions in Python. They are often used for simple operations that can be defined in a single line of code. Lambda functions are created using the lambda keyword, followed by a parameter list, a colon (:), and an expression. The expression is evaluated and returned when the lambda function is called.

Syntax of Lambda Expressions

The syntax for creating a lambda expression is as follows:

lambda parameters: expression

• lambda: The keyword that indicates the creation of a lambda function.
• parameters: An optional list of parameters (can be empty).
• :: Separates the parameter list from the expression.
• expression: The code to be executed when the lambda function is called.

Let’s look at some examples to better understand lambda expressions:

Regular Functions vs. Lambda Expressions

Regular Functions

In Python, we typically define functions using the def keyword, specifying the function’s name and its parameters within parentheses. Here’s an example:

def square(x):
    return x ** 2

When we create a regular function like square, it has a name, can accept parameters, and has a defined body with statements. You can think of regular functions as having a distinct identity, just like a named person.

Lambda Expression

Lambda expressions, on the other hand, are anonymous functions. They are defined using the lambda keyword and don’t have a name. Lambda expressions are concise and are often used for simple tasks. Here’s an example of a lambda expression that squares a number:

square = lambda x: x ** 2

As you can see, a lambda expression consists of the lambda keyword, followed by the parameter(s), a colon, and the expression to be evaluated. Lambda functions are like mysterious strangers in the night; you know what they do, but you don’t know their name.

Lambda with Two Parameters

lambda x, y: x + y

This lambda function takes two parameters x and y and returns their sum.

Example 3: Lambda with No Parameters

lambda: "Hello"

This lambda function has no parameters and returns the string "Hello".

Example 4: More Complex Lambda

lambda s: s[::-1].upper()

This lambda function takes a string s, reverses it, and converts it to uppercase. (Note: Slicing and string methods are used here.)

Using Lambda Expressions

Lambda expressions can be used in various ways, similar to regular functions. Here are some common use cases:

Assigning Lambda Expressions to Variables

You can assign a lambda expression to a variable for later use:

my_func = lambda x: x ** 2
result = my_func(3)  # Calls the lambda function

In this example, my_func becomes a variable holding the lambda function, and you can call it as you would with any other function.

Passing Lambda Functions as Arguments

Lambda functions can be passed as arguments to other functions, which is useful for defining custom behavior:

def apply_func(x, func):
    return func(x)

result = apply_func(3, lambda x: x ** 2)

The apply_func function takes an argument x and a function func and applies func to x.

Limitations of Lambda Expressions

Lambda expressions have some limitations:

• The body of a lambda must consist of a single expression, so you can’t have multiple statements or assignments within a lambda.
• Lambda expressions cannot have type annotations, making them less informative about the expected types of parameters.
• While line continuation is allowed for readability, lambdas are meant for concise expressions. If you find yourself needing multiple lines, consider using a regular function defined with def.

Lambdas and Sorting

In this section, we will explore the application of lambdas in sorting within the context of Python. Sorting is a fundamental operation in programming, and Python provides a versatile tool for this task through the sorted function. We will delve into various examples and scenarios where lambdas play a crucial role in customizing sorting behavior.

Basics of Sorting in Python

Python offers the sorted function, which efficiently sorts iterables like lists, dictionaries, sets, and tuples. It returns a new list with elements sorted in ascending order based on their natural ordering.

Example 1: Sorting a List of Numbers

Let’s start with a basic example by sorting a list of numbers:

numbers = [1, 5, 4, 10, 9, 5]
sorted_numbers = sorted(numbers)
# sorted_numbers will be [1, 4, 5, 5, 9, 10]

Note: sorted does not perform in-place sorting; it returns a new sorted list.

Customizing Sorting with Lambdas

The true power of sorted comes into play when we customize the sorting criteria using a key function, which accepts a lambda expression. This allows us to sort based on specific attributes or transformations of the elements.

Example 2: Case-Insensitive Sorting

Suppose we have a list of strings and want to sort them in a case-insensitive manner:

strings = ["C", "B", "D", "a"]
case_insensitive_sorted = sorted(strings, key=lambda s: s.upper())
# case_insensitive_sorted will be ["a", "B", "C", "D"]

Here, the lambda function transforms each string to its uppercase form for comparison.

Sorting Dictionaries

Sorting dictionaries based on keys or values is a common use case.

Example 3: Sorting a Dictionary by Keys

sample_dict = {'Def': 300, 'ABC': 200, 'Guy': 100}
sorted_keys = sorted(sample_dict.keys())
# sorted_keys will be ['ABC', 'Def', 'Guy']

Example 4: Sorting a Dictionary by Values

To sort a dictionary by its values, we can utilize a lambda function within the key argument:

sorted_values = sorted(sample_dict.keys(), key=lambda key: sample_dict[key])
# sorted_values will be ['Guy', 'ABC', 'Def']

Complex Number Sorting

Let’s explore a scenario where we want to sort a list of complex numbers based on their distance from the origin.

Example 5: Sorting Complex Numbers by Distance

import cmath

complex_numbers = [3 + 3j, 1 - 1j, 0, 3]
sorted_complex_numbers = sorted(complex_numbers, key=lambda x: abs(x)**2)
# sorted_complex_numbers will be [0, (1-1j), (3+0j), (3+3j)]

In this example, we calculate the squared distance from the origin using the abs function within the lambda.

Sorting by Specific Criteria

Sorting by specific criteria within elements can also be achieved using lambdas.

Example 6: Sorting by Last Character of Strings

Suppose we have a list of names and want to sort them based on the last character of each name:

names = ["Cleese", "Idle", "Palin", "Chapman", "Gilliam", "Jones"]
sorted_names = sorted(names, key=lambda name: name[-1])
# sorted_names will be ["Cleese", "Idle", "Palin", "Chapman", "Jones", "Gilliam"]

Here, the lambda extracts the last character for comparison, and the stable sorting property ensures the original order is maintained for equal elements.