Python Lambda

The lambdas are anonymous one line functions in Python that can be used to perform tasks which don't require regular Python functions. Some of the most useful features of Python lambdas are...

Lambda function can take any number of arguments
Lambda functions are very short although can be very encryptic
Lambda functions can be used to return function objects
Lambda functions are restricted to only a single expression

Below snippet shows the basic syntax of a Python function. The below function takes "argument" and returns it back.

# normal function that returns a valuedeffunctionName(argument):returnargument

Lambda Function Definion

Example of above function "functionName" using Lambda

lambdaargument:argument

<function __main__.<lambda>(argument)>

Note the syntax of the above function. Lambda functions have no name. They are defined and used on the fly. We can't reuse them in the form defined above. The first 'argument' is the argument of the function and the 2nd 'argument' is the returned value.

Example: - Lambda function that returns the twice of the given input.

lambdax:x*2

<function __main__.<lambda>(x)>

But you must be wondering, how to provide the input to above lambda function!

Calling the Lambda Function

To use the function, you can surround it with parenthesis and provide the parameters between paranthesis as shown below.

(lambdax:x*2)(5)

10

This is how it works...

# (lambda x: x * 2 )(5) = lambda 5 : 5 * 2 = 5 * 2 = 10

There is another way to provide an argument to the lambda function. We can assign the lambda function to a variable and then pass the argument to that variable as shown below...

double=lambdax:x*2# and call it like so : double(5)

10

Ofcourse above lambda function and below function are equivalent.

# the function double is equivalent to : defdouble(x):returnx*2

Lambda Functions With Mutiple Arguments

Python Lambda functions can have multipe parameters separated by commas (,) here is an example...

pairs=lambdax,y:"P( x = "+str(x)+" , y = "+str(y)+" )"pairs(1,2)

'P( x = 1 , y = 2 )'

There is a shorthand way of calling Python lambdas function that is without assigning a name to the function.

You can simply do this :

lambdaa,b:a*b

<function __main__.<lambda>(a, b)>

There will be no conflict and you can call the above lambda function with the arguments like this...

_(2,3)

6

Note the underscore in the above syntax. Underscore refers to the lambda function that we just described above.

Ofcourse, you can use IIFE ( Immediately Invoked Function Expression ) syntax too.

(lambdaa,b:a*b)(2,3)

6

High order Functions

We can use function inside lambda. Below snippet is an example of lambda function inside another lambda function.

# we can use a function as a parameter of lambda : myfunction=lambdaparam,func:param+func(param)# and call it like so : myfunction(3,lambdax:x**2)

12

In the above snippet, we passed outer lambda function two parameters - param and another lambda function (func)

myfunction(4,lambdax:x-1)

7

Python lambda and Regular Functions

importdisdiv=lambdax,y:x/ytype(div)

function

dis.dis(div)

  2           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_TRUE_DIVIDE
              6 RETURN_VALUE

div

<function __main__.<lambda>(x, y)>

# applaying same thing for a normal function: importdisdefdiv(x,y):returnx/ytype(div)

function

dis.dis(div)div

  4           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_TRUE_DIVIDE
              6 RETURN_VALUE

<function __main__.div(x, y)>

Lambda function Restrictions

Lambda functions throws similar errors as Python regular functions do. For example, below snippet will throw string multiplication error "can't multiply sequence by non-int of type 'str'"

type_error=lambdastr1,str2:str1*str2type_error("hello","world")

---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)
<ipython-input-19-17effbb67a31> in <module>      1 type_error =lambda str1,str2 : str1 * str2
----> 2type_error("hello","world")<ipython-input-19-17effbb67a31> in <lambda>(str1, str2)----> 1type_error =lambda str1,str2 : str1 * str2
      2 type_error("hello","world")TypeError: can't multiply sequence by non-int of type 'str'

Statements inside Lambda Function

We can't add statments in lambda function as shown below.

(lambdax:assertx>0)(1)

  File "<ipython-input-20-9947f5245b98>", line 1    (lambda x : assert x > 0)(1)
                     ^
SyntaxError: invalid syntax

However we can use parenthesis to achieve the statement effect.

In below snippet, note expression (x>0 and + or '-') would translate to if x > 0 then return '+' otherwise return '-'

(lambdax:(x>0and'+'or'-'))(-5)

'-'

Type Annotation

Hinting doesn't work on lambda functions. It only works on normal functions.

Below regular Python function takes 'string' and 'integer' as two parameters but returns output as string.

deffunction(param:str,i:int)->str:returnparam*str(i)

In lambda function, if you specify type hints, you will end up getting a syntaxError...

lambdaparam:str,i:int:param*i

  File "<ipython-input-23-c1c4c22920e0>", line 1    lambda param:str , i : int : param * i
                               ^
SyntaxError: invalid syntax

*args and **kwargs in Python Lambda

As we described above in the 'multiple arguments section' of this post, Python lambda function can take multiple arguments but lambda functions can also take arguments using *arg and **kwargs

(lambdap1,p2,p3:(p1+p2+p3)/3)(1,2,3)

2.0

(lambdap1,p2,p3=3:(p1+p2+p3)/3)(1,2)

2.0

*args example

(lambda*args:sum(args)/len(args))(1,2,3)

2.0

**kwargs example

(lambda**kwargs:sum(kwargs.values())/len(kwargs))(one=1,two=2,three=3)

2.0

Python lambdas initialize arguments example

(lambdap1,p2=0,p3=0:(p1+p2+p3)/3)(1,p2=2,p3=3)

2.0

Decorator in Python Lambda Function

Let us see first, how decorators in regular Python functions work. Here is an example...

# Defining a decoratordeftrace(f):defwrap(*args,**kwargs):print(f"[TRACE] function name: {f.__name__}, arguments: {args}, kwargs: {kwargs}")returnf(*args,**kwargs)returnwrap# Applying decorator to a function@tracedefdouble(x):returnx*2# Calling the decorated functiondouble(3)

[TRACE] function name: double, arguments: (3,), kwargs: {}

6

Check out below example of application of decorator to a lambda function. Notice in the below snippet, how we have wrapped the lambda function inside the trace decorator function. Order of brackets is very important.

print((trace(lambdax:x*2))(3))

[TRACE] function name: <lambda>, arguments: (3,), kwargs: {}
6

Python lambda with map and filter

Lambda is regularly used with built-in functions like map or filter.

Python map

map iterates the function through a list or set. The function could be regular Python function or lambda function.

In the below example,lambda function x: x + 5 is applied on list of numbers (0,4)

list(map(lambdax:x+5,range(5)))

[5, 6, 7, 8, 9]

Python filter

In the below example,lambda function x: x > 0 is applied on list of numbers [-5,-2,1,0,3,5]

list(filter(lambdax:x>0,[-5,-2,1,0,3,5]))

[1, 3, 5]

Decorators in lamda with Python map

In below snippet, map() is taking two arguments. The first one is the decorator function around lambda function i.e.

trace(lambda x: x * 2) and second argument is range(3).

The map() will run the decorated lambda function 3 times as shown below.

list(map(trace(lambdax:x*2),range(3)))

[TRACE] function name: <lambda>, arguments: (0,), kwargs: {}
[TRACE] function name: <lambda>, arguments: (1,), kwargs: {}
[TRACE] function name: <lambda>, arguments: (2,), kwargs: {}

[0, 2, 4]

Testing Python Lambda with Unittest

importunittestdouble=lambdax:x*2classTest(unittest.TestCase):deftest_1(self):self.assertEqual(double(1),2)deftest_2(self):self.assertEqual(double(2),4)deftest_10(self):self.assertEqual(double(10),11)# this test will failif__name__=='__main__':unittest.main(verbosity=2)

double=lambdax:x*2double.__doc__="""Doubles the number entred in the parameters :>>> double(1)2>>> double(2.0)4.0>>> double(10)20"""if__name__=='__main__':importdoctestdoctest.testmod(verbose=True)

Trying:
    double(1)
Expecting:
    2
ok
Trying:
    double(2.0)
Expecting:
    4.0
ok
Trying:
    double(10)
Expecting:
    20
ok
16 items had no tests:
    __main__
    __main__.Test
    __main__.Test.test_1
    __main__.Test.test_10
    __main__.Test.test_2
    __main__._16
    __main__._2
    __main__._3
    __main__._9
    __main__.div
    __main__.function
    __main__.functionName
    __main__.myfunction
    __main__.pairs
    __main__.trace
    __main__.type_error
1 items passed all tests:
   3 tests in __main__.double
3 tests in 17 items.
3 passed and 0 failed.
Test passed.

Python Lambda raise Exception

Here is how regular Python function raises exception.

defthrow(excep):raiseexcep

Here is how lambda functions can raise exception.

(lambda:throw(Exception("my error")))()

---------------------------------------------------------------------------Exception                                 Traceback (most recent call last)
<ipython-input-38-2dcbdacea675> in <module>----> 1(lambda: throw(Exception("my error")))()<ipython-input-38-2dcbdacea675> in <lambda>()----> 1(lambda: throw(Exception("my error")))()<ipython-input-37-5de1b89d45c1> in throw(excep)      1def throw(excep):----> 2raise excep

Exception: my error

Lambda Cryptic Code Using underscore

Let us look at below example. In here (lambda : * 2) _ refers to a variable or parameter.

(lambda_:_*2)(11)

22

Let us take at following more cryptic code example. In below code, there are two Python lambda functions. The parameter _ is being used inside both lambda functions.

(lambda_:list(map(lambda_:_*2,_)))(range(11))

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# the underscore (_) is the variable # to simplify, the function should be like this : (lambdamyList:list(map(lambdaelement:element*2,myList)))(range(11))

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Here is how it works.

lambda 0 : list(map(lambda : *2,0)) \ lambda 0 : list(0) \ 0

lambda 1: list(map(lambda : *2, 1)) \ lambda 1: list(2) \ 2 \ ....

Here is the above code in a regular Pythonic way...

# regular functions will make it easy due to their multiline formatdefdoubleItems(myList):double=lambdax:x*2returnmap(double,myList)list(doubleItems(range(11)))

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Python lambda using Key function

# let's sort a list of strings that have a char a space and an int based ont he value of the integermyList=["a 1","b 45","x 11","r 16"]print(sorted(myList))print(sorted(myList,key=lambdax:int(x[2:])))

['a 1', 'b 45', 'r 16', 'x 11']
['a 1', 'x 11', 'r 16', 'b 45']

Timeit lambda function

fromtimeitimporttimeittimeit(lambda:sum(range(99999)),number=10)# this silution is cleaner and more readable

0.013398005161434412