8.5.1. What is a Lambda Function?

• Anonymous, single-expression functions.

Lambda functions are a special kind of function in Python that are defined without a name, which is why they are often referred to as 'anonymous' functions. They are used to create small functions that can have a single expression. Unlike regular functions defined using the 'def' keyword, lambda functions are defined using the 'lambda' keyword followed by the arguments they take and the expression they compute.

Think of lambda functions like a one-time-use tool, like a paint roller used to quickly coat a wall with paint. Once the task is done, you might not need to use that paint roller again, just like how you may only need a small function for a specific, temporary computation in a program.

• Syntax: lambda arguments: expression

square = lambda x: x**2 print(square(4)) # Output: 16

The syntax for a lambda function follows this structure: 'lambda arguments: expression'. The 'arguments' are the inputs that the lambda function can take, and the 'expression' is what the lambda function computes and returns. For example, 'square = lambda x: x**2' defines a lambda function named 'square' that takes one input, 'x', and returns 'x' squared. When we execute 'print(square(4))', it calculates the square of 4 and outputs 16.

Imagine you have a magic box that can square numbers for you. You place 4 into the box (which represents our lambda function), and out comes 16. The magic box works every time you input a number and provides the squared value instantly.

Useful in: • Sorting • Mapping • Filtering

Lambda functions are particularly useful in scenarios where small, simple functions are needed and can simplify your code significantly. Common use cases include:

1. Sorting: You might need to sort a list of items based on a specific criterion, for example, sorting a list of tuples by the second item in each tuple.
2. Mapping: Applying a transformation to each item in a list, such as squaring every number in a list.
3. Filtering: Selecting items from a list that meet certain conditions, such as keeping only even numbers. Lambda functions can be utilized in combination with functions like map(), filter(), and sorted().

Think of sorting a deck of cards by suit and then by number. If you had a quick tool (your lambda function) that could look at a card and tell you how to rank it without needing a lengthy setup, you’d accomplish the task faster. The lambda acts like that quick tool that you can deploy in various situations, from mapping transformations to filtering choices.

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

In this example, we have a list of numbers named 'nums' containing values [1, 2, 3, 4]. We want to create a new list where each number from 'nums' is squared. Instead of writing a separate function, we can use a lambda function combined with the 'map()' function. The 'map()' function takes two arguments: the lambda that squares each number and the list 'nums'. The result is a new list 'squared', which contains [1, 4, 9, 16]. By using this approach, we make our code concise and readable while achieving the desired result quickly.

Imagine you have a set of images and you want to apply a filter that sharpens every image. Rather than manually editing each image, you can set up a quick process (like our lambda function) that automatically sharpens all images in one go, producing a set of enhanced images effortlessly.

--