ALWAYSINFOTECH LEARNING CENTRE
ADVANCE PYTHON : LAMBDA FUNCTIONS
In Python, a lambda function, also known as an
anonymous function, is a small and anonymous
function that doesn't have a name. It is defined
using the lambda keyword and can take any number
of arguments but can only have a single
expression.
The general syntax of a lambda function is as
follows:
lambda arguments: expression
Here, arguments represent the input parameters or
arguments passed to the lambda function, and
expression is the single expression or
calculation that is executed when the lambda
function is called. The result of the expression
is automatically returned by the lambda
function.
Lambda functions are commonly used when you need
a simple function that is only required at a
particular point in your code and doesn't need a
formal definition. They are often used in
conjunction with higher-order functions like
map(), filter(), and reduce().
Here's an example to illustrate the usage of
lambda functions:
# Simple lambda function to square a number
square = lambda x: x ** 2
print(square(5)) # Output: 25
# Using lambda with map() to double each number
numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(lambda x: x * 2,
numbers))
print(doubled_numbers) # Output: [2, 4, 6, 8,
10]
In the above example, the lambda function square
squares the input argument x. The lambda
function used with map() doubles each number in
the list numbers.
WHY TO USE LAMBDA?
While both regular functions and lambda
functions can achieve similar results, lambda
functions offer some advantages in certain
scenarios:
1. Conciseness: Lambda functions are typically
more concise than regular functions. They
allow you to define a function in a single
line of code, making them handy for simple
calculations or transformations.
2. Readability: Lambda functions can make your
code more readable when the function logic is
straightforward and doesn't require complex
statements or multiple lines. They can
provide a more compact representation of the
function's purpose, especially when used with
higher-order functions like map() or filter().
3. Avoiding Function Overhead: Lambda
functions don't require a separate function
definition, which means you don't need to
assign them a name or declare them elsewhere
in your code. This can be beneficial when you
need to define small, throwaway functions
that won't be reused elsewhere.
4. Inline Usage: Lambda functions can be used
directly in places where a function is
expected as an argument, without the need to
define a separate named function. This allows
for a more flexible and convenient coding
style, especially when working with
functional programming concepts.
However, it's important to note that lambda
functions have limitations compared to regular
functions. They are restricted to a single
expression, which means they cannot include
multiple statements or complex logic. If your
function requires more extensive logic or will
be reused in multiple places, a regular function
with a proper name and defined structure would
be more appropriate and maintainable.
In summary, lambda functions are useful when you
need a simple, concise function for a specific
task and want to avoid the overhead of defining
a named function. They shine when used in
conjunction with higher-order functions and
provide a more compact and inline approach to
function definition. However, for more complex
functions or ones that will be reused, regular
functions offer better readability and
maintainability.
