# Python Anonymous Function (Lambda) – Tutorial with Examples

In Python, an anonymous function is a function that is defined without a name. Anonymous functions are also known as lambda functions. These functions are small, concise, and quick to define. They are most commonly used when a function is needed only once or when the function is only required in a specific context, such as in a single method. In this article, we will explore what anonymous functions are, how they are defined, and how they can be used in practical examples.

## Syntax of Anonymous Function

The syntax for defining an anonymous function in Python is as follows:

`lambda arguments: expression`

Where “arguments” are the inputs to the function and “expression” is the operation to be performed on the inputs.

## Example of Anonymous Function

Here is a simple example of an anonymous function that adds two numbers:

```sum = lambda a, b: a + b
print(sum(5, 3))
# Output: 8```

In this example, the anonymous function takes two arguments, “a” and “b”, and returns the sum of these two numbers. The function is assigned to a variable “sum” and can be used just like any other function. This function can also be used as an argument to other functions, such as the built-in “map” function, which applies a function to each element of an iterable object:

```numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers)
# Output: [1, 4, 9, 16, 25]```

In this example, the anonymous function “lambda x: x**2” takes a single argument “x” and returns the square of the number. The “map” function applies this anonymous function to each element of the list “numbers” and returns a list of the squares of these numbers.

Let’s consider a scenario where we have a list of strings and we want to sort the list based on the length of each string. This can be achieved using a lambda function as follows:

```strings = ["apple", "banana", "cherry", "date"]
sorted_strings = sorted(strings, key=lambda x: len(x))
print(sorted_strings)
# Output: ['date', 'apple', 'banana', 'cherry']
```

In this example, the lambda function “lambda x: len(x)” takes a single argument “x” and returns the length of the string. The built-in “sorted” function takes the list of strings and sorts it based on the key function, which is the lambda function that calculates the length of each string. This results in a sorted list of strings based on their length.

It’s important to note that the same result could have been achieved using a regular, named function, but the anonymous function provides a more concise and readable solution in this specific scenario.

Here are some of the advantages of using anonymous functions in Python:

• Concise and easy to write – Anonymous functions are small and simple to define, making them ideal for one-time use or for use in specific contexts.
• Flexible – Anonymous functions can be used as arguments to other functions, making them very flexible and reusable in a variety of contexts.
• Avoid naming conflicts – When a function is only needed once or in a specific context, using an anonymous function avoids naming conflicts with other functions in your code.