History

Alonzo Church formalizedlambda calculus, a language based on pure abstraction, in the 1930s. Lambda functions are also referred to as lambda abstractions, a direct reference to the abstraction model of Alonzo Church’s original creation.

Lambda calculus can encode any computation. It isTuring complete, but contrary to the concept of aTuring machine, it is pure and does not keep any state.

Functional languages get their origin in mathematical logic and lambda calculus, while imperative programming languages embrace the state-based model of computation invented by Alan Turing. The two models of computation, lambda calculus andTuring machines, can be translated into each another. This equivalence is known as theChurch-Turing hypothesis.

Functional languages directly inherit the lambda calculus philosophy, adopting a declarative approach of programming that emphasizes abstraction, data transformation, composition, and purity (no state and no side effects). Examples of functional languages includeHaskell,Lisp, orErlang.

By contrast, the Turing Machine led to imperative programming found in languages likeFortran,C, orPython.

The imperative style consists of programming with statements, driving the flow of the program step by step with detailed instructions. This approach promotes mutation and requires managing state.

The separation in both families presents some nuances, as some functional languages incorporate imperative features, likeOCaml, while functional features have been permeating the imperative family of languages in particular with the introduction of lambda functions inJava, or Python.

Python is not inherently a functional language, but it adopted some functional concepts early on. In January 1994,map(),filter(),reduce(), and thelambda operator were added to the language.

First Example

Here are a few examples to give you an appetite for some Python code, functional style.

Theidentity function, a function that returns its argument, is expressed with a standard Python function definition using thekeyworddef as follows:

>>>defidentity(x):...returnx

identity() takes an argumentx and returns it upon invocation.

In contrast, if you use a Python lambda construction, you get the following:

>>>lambdax:x

In the example above, the expression is composed of:

• The keyword:lambda
• A bound variable:x
• A body:x

You can write a slightly more elaborated example, a function that adds1 to an argument, as follows:

>>>lambdax:x+1

You can apply the function above to an argument by surrounding the function and its argument with parentheses:

>>>(lambdax:x+1)(2)3

Reduction is a lambda calculus strategy to compute the value of the expression. In the current example, it consists of replacing the bound variablex with the argument2:

(lambda x: x + 1)(2) = lambda 2: 2 + 1                     = 2 + 1                     = 3

Because a lambda function is an expression, it can be named. Therefore you could write the previous code as follows:

>>>add_one=lambdax:x+1>>>add_one(2)3

The above lambda function is equivalent to writing this:

defadd_one(x):returnx+1

These functions all take a single argument. You may have noticed that, in the definition of the lambdas, the arguments don’t have parentheses around them. Multi-argument functions (functions that take more than one argument) are expressed in Python lambdas by listing arguments and separating them with a comma (,) but without surrounding them with parentheses:

>>>full_name=lambdafirst,last:f'Full name:{first.title()}{last.title()}'>>>full_name('guido','van rossum')'Full name: Guido Van Rossum'

The lambda function assigned tofull_name takes two arguments and returns astring interpolating the two parametersfirst andlast. As expected, the definition of the lambda lists the arguments with no parentheses, whereas calling the function is done exactly like a normalPython function, with parentheses surrounding the arguments.

Functions

At this point, you may wonder what fundamentally distinguishes a lambda function bound to a variable from a regular function with a singlereturn line: under the surface, almost nothing. Let’s verify how Python sees a function built with a singlereturn statement versus a function constructed as an expression (lambda).

Thedis module exposes functions to analyze Python bytecode generated by the Python compiler:

>>>importdis>>>add=lambdax,y:x+y>>>type(add)<class 'function'>>>>dis.dis(add)  1           0 LOAD_FAST                0 (x)              2 LOAD_FAST                1 (y)              4 BINARY_ADD              6 RETURN_VALUE>>>add<function <lambda> at 0x7f30c6ce9ea0>

You can see thatdis() expose a readable version of the Python bytecode allowing the inspection of the low-level instructions that the Python interpreter will use while executing the program.

Now see it with a regular function object:

>>>importdis>>>defadd(x,y):returnx+y>>>type(add)<class 'function'>>>>dis.dis(add)  1           0 LOAD_FAST                0 (x)              2 LOAD_FAST                1 (y)              4 BINARY_ADD              6 RETURN_VALUE>>>add<function add at 0x7f30c6ce9f28>

The bytecode interpreted by Python is the same for both functions. But you may notice that the naming is different: the function name isadd for a function defined withdef, whereas the Python lambda function is seen aslambda.

Traceback

You saw in the previous section that, in the context of the lambda function, Python did not provide the name of the function, but only<lambda>. This can be a limitation to consider when an exception occurs, and atraceback shows only<lambda>:

>>>div_zero=lambdax:x/0>>>div_zero(2)Traceback (most recent call last):File"<stdin>",line1,in<module>File"<stdin>",line1,in<lambda>ZeroDivisionError:division by zero

Thetraceback of an exception raised while a lambda function is executed only identifies the function causing the exception as<lambda>.

Here’s the same exception raised by a normal function:

>>>defdiv_zero(x):returnx/0>>>div_zero(2)Traceback (most recent call last):File"<stdin>",line1,in<module>File"<stdin>",line1,indiv_zeroZeroDivisionError:division by zero

The normal function causes a similar error but results in a more precise traceback because it gives the function name,div_zero.

Syntax

As you saw in the previous sections, a lambda form presents syntactic distinctions from a normal function. In particular, a lambda function has the following characteristics:

• It can only contain expressions and can’t include statements in its body.
• It is written as a single line of execution.
• It does not support type annotations.
• It can be immediately invoked (IIFE).

No Statements

A lambda function can’t contain any statements. In a lambda function, statements likereturn,pass,assert, orraise will raise aSyntaxError exception. Here’s an example of addingassert to the body of a lambda:

>>>(lambdax:assertx==2)(2)  File"<input>", line1(lambdax:assertx==2)(2)^SyntaxError:invalid syntax

This contrived example intended toassert that parameterx had a value of2. But, the interpreter identifies aSyntaxError while parsing the code that involves the statementassert in the body of thelambda.

Single Expression

In contrast to a normal function, a Python lambda function is a single expression. Although, in the body of alambda, you can spread the expression over several lines using parentheses or a multiline string, it remains a single expression:

>>>(lambdax:...(x%2and'odd'or'even'))(3)'odd'

The example above returns the string'odd' when the lambda argument is odd, and'even' when the argument is even. It spreads across two lines because it is contained in a set of parentheses, but it remains a single expression.

Type Annotations

If you’ve started adopting type hinting, which is now available in Python, then you have another good reason to prefer normal functions over Python lambda functions. Check outPython Type Checking (Guide) to get learn more about Python type hints and type checking. In a lambda function, there is no equivalent for the following:

deffull_name(first:str,last:str)->str:returnf'{first.title()}{last.title()}'

Any type error withfull_name() can be caught by tools likemypy orpyre, whereas aSyntaxError with the equivalent lambda function is raised at runtime:

>>>lambdafirst:str,last:str:first.title()+" "+last.title()->str  File"<stdin>", line1lambdafirst:str,last:str:first.title()+" "+last.title()->strSyntaxError:invalid syntax

Like trying to include a statement in a lambda, adding type annotation immediately results in aSyntaxError at runtime.

IIFE

You’ve already seen several examples ofimmediately invoked function execution:

>>>(lambdax:x*x)(3)9

Outside of the Python interpreter, this feature is probably not used in practice. It’s a direct consequence of a lambda function being callable as it is defined. For example, this allows you to pass the definition of a Python lambda expression to a higher-order function likemap(),filter(), orfunctools.reduce(), or to a key function.

Arguments

Like a normal function object defined withdef, Python lambda expressions support all the different ways of passing arguments. This includes:

• Positional arguments
• Named arguments (sometimes called keyword arguments)
• Variable list of arguments (often referred to asvarargs)
• Variable list of keyword arguments
• Keyword-only arguments

The following examples illustrate options open to you in order to pass arguments to lambda expressions:

>>>(lambdax,y,z:x+y+z)(1,2,3)6>>>(lambdax,y,z=3:x+y+z)(1,2)6>>>(lambdax,y,z=3:x+y+z)(1,y=2)6>>>(lambda*args:sum(args))(1,2,3)6>>>(lambda**kwargs:sum(kwargs.values()))(one=1,two=2,three=3)6>>>(lambdax,*,y=0,z=0:x+y+z)(1,y=2,z=3)6

Decorators

In Python, adecorator is the implementation of a pattern that allows adding a behavior to a function or a class. It is usually expressed with the@decorator syntax prefixing a function. Here’s a contrived example:

defsome_decorator(f):defwraps(*args):print(f"Calling function '{f.__name__}'")returnf(args)returnwraps@some_decoratordefdecorated_function(x):print(f"With argument '{x}'")

In the example above,some_decorator() is a function that adds a behavior todecorated_function(), so that invokingdecorated_function("Python") results in the following output:

Calling function 'decorated_function'With argument 'Python'

decorated_function() only printsWith argument 'Python', but the decorator adds an extra behavior that also printsCalling function 'decorated_function'.

A decorator can be applied to a lambda. Although it’s not possible to decorate a lambda with the@decorator syntax, a decorator is just a function, so it can call the lambda function:

 1# Defining a decorator 2deftrace(f): 3defwrap(*args,**kwargs): 4print(f"[TRACE] func:{f.__name__}, args:{args}, kwargs:{kwargs}") 5returnf(*args,**kwargs) 6 7returnwrap 8 9# Applying decorator to a function10@trace11defadd_two(x):12returnx+21314# Calling the decorated function15add_two(3)1617# Applying decorator to a lambda18print((trace(lambdax:x**2))(3))

add_two(), decorated with@trace on line 11, is invoked with argument3 on line 15. By contrast, on line 18, a lambda function is immediately involved and embedded in a call totrace(), the decorator. When you execute the code above you obtain the following:

[TRACE] func: add_two, args: (3,), kwargs: {}[TRACE] func: <lambda>, args: (3,), kwargs: {}9

See how, as you’ve already seen, the name of the lambda function appears as<lambda>, whereasadd_two is clearly identified for the normal function.

Decorating the lambda function this way could be useful for debugging purposes, possibly to debug the behavior of a lambda function used in the context of a higher-order function or a key function. Let’s see an example withmap():

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

The first argument ofmap() is a lambda that multiplies its argument by2. This lambda is decorated withtrace(). When executed, the example above outputs the following:

[TRACE] Calling <lambda> with args (0,) and kwargs {}[TRACE] Calling <lambda> with args (1,) and kwargs {}[TRACE] Calling <lambda> with args (2,) and kwargs {}[0, 2, 4]

The result[0, 2, 4] is alist obtained from multiplying each element ofrange(3). For now, considerrange(3) equivalent to the list[0, 1, 2].

You will be exposed tomap() in more details inMap.

A lambda can also be a decorator, but it’s not recommended. If you find yourself needing to do this, consultPEP 8, Programming Recommendations.

For more on Python decorators, check outPrimer on Python Decorators.

Closure

Aclosure is a function where every free variable, everything except parameters, used in that function is bound to a specific value defined in the enclosing scope of that function. In effect, closures define the environment in which they run, and so can be called from anywhere.

The concepts of lambdas and closures are not necessarily related, although lambda functions can be closures in the same way that normal functions can also be closures. Some languages have special constructs for closure or lambda (for example, Groovy with an anonymous block of code as Closure object), or a lambda expression (for example, Java Lambda expression with a limited option for closure).

Here’s a closure constructed with a normal Python function:

 1defouter_func(x): 2y=4 3definner_func(z): 4print(f"x ={x}, y ={y}, z ={z}") 5returnx+y+z 6returninner_func 7 8foriinrange(3): 9closure=outer_func(i)10print(f"closure({i+5}) ={closure(i+5)}")

outer_func() returnsinner_func(), anested function that computes the sum of three arguments:

• x is passed as an argument toouter_func().
• y is a variable local toouter_func().
• z is an argument passed toinner_func().

To test the behavior ofouter_func() andinner_func(),outer_func() is invoked three times in afor loop that prints the following:

x = 0, y = 4, z = 5closure(5) = 9x = 1, y = 4, z = 6closure(6) = 11x = 2, y = 4, z = 7closure(7) = 13

On line 9 of the code,inner_func() returned by the invocation ofouter_func() is bound to the nameclosure. On line 5,inner_func() capturesx andy because it has access to its embedding environment, such that upon invocation of the closure, it is able to operate on the two free variablesx andy.

Similarly, alambda can also be a closure. Here’s the same example with a Python lambda function:

 1defouter_func(x): 2y=4 3returnlambdaz:x+y+z 4 5foriinrange(3): 6closure=outer_func(i) 7print(f"closure({i+5}) ={closure(i+5)}")

When you execute the code above, you obtain the following output:

closure(5) = 9closure(6) = 11closure(7) = 13

On line 6,outer_func() returns a lambda and assigns it to to the variableclosure. On line 3, the body of the lambda function referencesx andy. The variabley is available at definition time, whereasx is defined at runtime whenouter_func() is invoked.

In this situation, both the normal function and the lambda behave similarly. In the next section, you’ll see a situation where the behavior of a lambda can be deceptive due to its evaluation time (definition time vs runtime).

Evaluation Time

In some situations involvingloops, the behavior of a Python lambda function as a closure may be counterintuitive. It requires understanding when free variables are bound in the context of a lambda. The following examples demonstrate the difference when using a regular function vs using a Python lambda.

Test the scenario first using a regular function:

 1>>>defwrap(n): 2...deff(): 3...print(n) 4...returnf 5... 6>>>numbers='one','two','three' 7>>>funcs=[] 8>>>forninnumbers: 9...funcs.append(wrap(n))10...11>>>forfinfuncs:12...f()13...14one15two16three

In a normal function,n is evaluated at definition time, on line 9, when the function is added to the list:funcs.append(wrap(n)).

Now, with the implementation of the same logic with a lambda function, observe the unexpected behavior:

 1>>>numbers='one','two','three' 2>>>funcs=[] 3>>>forninnumbers: 4...funcs.append(lambda:print(n)) 5... 6>>>forfinfuncs: 7...f() 8... 9three10three11three

The unexpected result occurs because the free variablen, as implemented, is bound at the execution time of the lambda expression. The Python lambda function on line 4 is a closure that capturesn, a free variable bound at runtime. At runtime, while invoking the functionf on line 7, the value ofn isthree.

To overcome this issue, you can assign the free variable at definition time as follows:

 1>>>numbers='one','two','three' 2>>>funcs=[] 3>>>forninnumbers: 4...funcs.append(lambdan=n:print(n)) 5... 6>>>forfinfuncs: 7...f() 8... 9one10two11three

A Python lambda function behaves like a normal function in regard to arguments. Therefore, a lambda parameter can be initialized with a default value: the parametern takes the outern as a default value. The Python lambda function could have been written aslambda x=n: print(x) and have the same result.

The Python lambda function is invoked without any argument on line 7, and it uses the default valuen set at definition time.

Testing Lambdas

Python lambdas can be tested similarly to regular functions. It’s possible to use bothunittest anddoctest.

unittest

Theunittest module handles Python lambda functions similarly to regular functions:

importunittestaddtwo=lambdax:x+2classLambdaTest(unittest.TestCase):deftest_add_two(self):self.assertEqual(addtwo(2),4)deftest_add_two_point_two(self):self.assertEqual(addtwo(2.2),4.2)deftest_add_three(self):# Should failself.assertEqual(addtwo(3),6)if__name__=='__main__':unittest.main(verbosity=2)

LambdaTest defines a test case with three test methods, each of them exercising a test scenario foraddtwo() implemented as a lambda function. The execution of the Python filelambda_unittest.py that containsLambdaTest produces the following:

$pythonlambda_unittest.pytest_add_three (__main__.LambdaTest) ... FAILtest_add_two (__main__.LambdaTest) ... oktest_add_two_point_two (__main__.LambdaTest) ... ok======================================================================FAIL: test_add_three (__main__.LambdaTest)----------------------------------------------------------------------Traceback (most recent call last):  File "lambda_unittest.py", line 18, in test_add_three    self.assertEqual(addtwo(3), 6)AssertionError: 5 != 6----------------------------------------------------------------------Ran 3 tests in 0.001sFAILED (failures=1)

As expected, we have two successful test cases and one failure fortest_add_three: the result is5, but the expected result was6. This failure is due to an intentional mistake in the test case. Changing the expected result from6 to5 will satisfy all the tests forLambdaTest.

doctest

Thedoctest module extracts interactive Python code fromdocstring to execute tests. Although the syntax of Python lambda functions does not support a typicaldocstring, it is possible to assign a string to the__doc__ element of a named lambda:

addtwo=lambdax:x+2addtwo.__doc__="""Add 2 to a number.    >>> addtwo(2)    4    >>> addtwo(2.2)    4.2    >>> addtwo(3) # Should fail    6    """if__name__=='__main__':importdoctestdoctest.testmod(verbose=True)

Thedoctest in the doc comment of lambdaaddtwo() describes the same test cases as in the previous section.

When you execute the tests viadoctest.testmod(), you get the following:

$pythonlambda_doctest.pyTrying:    addtwo(2)Expecting:    4okTrying:    addtwo(2.2)Expecting:    4.2okTrying:    addtwo(3) # Should failExpecting:    6**********************************************************************File "lambda_doctest.py", line 16, in __main__.addtwoFailed example:    addtwo(3) # Should failExpected:    6Got:    51 items had no tests:    __main__**********************************************************************1 items had failures:   1 of   3 in __main__.addtwo3 tests in 2 items.2 passed and 1 failed.***Test Failed*** 1 failures.

The failed test results from the same failure explained in the execution of the unit tests in the previous section.

You can add adocstring to a Python lambda via an assignment to__doc__ to document a lambda function. Although possible, the Python syntax better accommodatesdocstring for normal functions than lambda functions.

For a comprehensive overview of unit testing in Python, you may want to refer toGetting Started With Testing in Python.

Raising an Exception

Trying to raise an exception in a Python lambda should make you think twice. There are some clever ways to do so, but even something like the following is better to avoid:

>>>defthrow(ex):raiseex>>>(lambda:throw(Exception('Something bad happened')))()Traceback (most recent call last):File"<stdin>",line1,in<module>File"<stdin>",line1,in<lambda>File"<stdin>",line1,inthrowException:Something bad happened

Because a statement is not syntactically correct in a Python lambda body, the workaround in the example above consists of abstracting the statement call with a dedicated functionthrow(). Using this type of workaround should be avoided. If you encounter this type of code, you should consider refactoring the code to use a regular function.

Cryptic Style

As in any programming languages, you will find Python code that can be difficult to read because of the style used. Lambda functions, due to their conciseness, can be conducive to writing code that is difficult to read.

The following lambda example contains several bad style choices:

>>>(lambda_:list(map(lambda_:_//2,_)))([1,2,3,4,5,6,7,8,9,10])[0, 1, 1, 2, 2, 3, 3, 4, 4, 5]

The underscore (_) refers to a variable that you don’t need to refer to explicitly. But in this example, three_ refer to different variables. An initial upgrade to this lambda code could be to name the variables:

>>>(lambdasome_list:list(map(lambdan:n//2,                                some_list)))([1,2,3,4,5,6,7,8,9,10])[0, 1, 1, 2, 2, 3, 3, 4, 4, 5]

Admittedly, it’s still difficult to read. By still taking advantage of alambda, a regular function would go a long way to render this code more readable, spreading the logic over a few lines and function calls:

>>>defdiv_items(some_list):      div_by_two = lambda n: n // 2      return map(div_by_two, some_list)>>>list(div_items([1,2,3,4,5,6,7,8,9,10])))[0, 1, 1, 2, 2, 3, 3, 4, 4, 5]

This is still not optimal but shows you a possible path to make code, and Python lambda functions in particular, more readable. InAlternatives to Lambdas, you’ll learn to replacemap() andlambda with list comprehensions orgenerator expressions. This will drastically improve the readability of the code.

Python Classes

You can but should not writeclass methods as Python lambda functions. The following example is perfectly legal Python code but exhibits unconventional Python code relying onlambda. For example, instead of implementing__str__ as a regular function, it uses alambda. Similarly,brand andyear areproperties also implemented with lambda functions, instead of regular functions or decorators:

classCar:"""Car with methods as lambda functions."""def__init__(self,brand,year):self.brand=brandself.year=yearbrand=property(lambdaself:getattr(self,'_brand'),lambdaself,value:setattr(self,'_brand',value))year=property(lambdaself:getattr(self,'_year'),lambdaself,value:setattr(self,'_year',value))__str__=lambdaself:f'{self.brand}{self.year}'# 1: error E731honk=lambdaself:print('Honk!')# 2: error E731

Running a tool likeflake8, a style guide enforcement tool, will display the following errors for__str__ andhonk:

E731 do not assign a lambda expression, use a def

Althoughflake8 doesn’t point out an issue for the usage of the Python lambda functions in the properties, they are difficult to read and prone to error because of the usage of multiple strings like'_brand' and'_year'.

Proper implementation of__str__ would be expected to be as follows:

def__str__(self):returnf'{self.brand}{self.year}'

brand would be written as follows:

@propertydefbrand(self):returnself._brand@brand.setterdefbrand(self,value):self._brand=value

As a general rule, in the context of code written in Python, prefer regular functions over lambda expressions. Nonetheless, there are cases that benefit from lambda syntax, as you will see in the next section.

Classic Functional Constructs

Lambda functions are regularly used with the built-in functionsmap() andfilter(), as well asfunctools.reduce(), exposed in the modulefunctools. The following three examples are respective illustrations of using those functions with lambda expressions as companions:

>>>list(map(lambdax:x.upper(),['cat','dog','cow']))['CAT', 'DOG', 'COW']>>>list(filter(lambdax:'o'inx,['cat','dog','cow']))['dog', 'cow']>>>fromfunctoolsimportreduce>>>reduce(lambdaacc,x:f'{acc} |{x}',['cat','dog','cow'])'cat | dog | cow'

You may have to read code resembling the examples above, albeit with more relevant data. For that reason, it’s important to recognize those constructs. Nevertheless, those constructs have equivalent alternatives that are considered more Pythonic. InAlternatives to Lambdas, you’ll learn how to convert higher-order functions and their accompanying lambdas into other more idiomatic forms.

Key Functions

Key functions in Python are higher-order functions that take a parameterkey as a named argument.key receives a function that can be alambda. This function directly influences the algorithm driven by the key function itself. Here are some key functions:

• sort(): list method
• sorted(),min(),max(): built-in functions
• nlargest() andnsmallest(): in the Heap queue algorithm moduleheapq

Imagine that you want to sort a list of IDs represented as strings. Each ID is theconcatenation of the stringid and a number. Sorting this list with the built-in functionsorted(), by default, uses a lexicographic order as the elements in the list are strings.

To influence the sorting execution, you can assign a lambda to the named argumentkey, such that the sorting will use the number associated with the ID:

>>>ids=['id1','id2','id30','id3','id22','id100']>>>print(sorted(ids))# Lexicographic sort['id1', 'id100', 'id2', 'id22', 'id3', 'id30']>>>sorted_ids=sorted(ids,key=lambdax:int(x[2:]))# Integer sort>>>print(sorted_ids)['id1', 'id2', 'id3', 'id22', 'id30', 'id100']

UI Frameworks

UI frameworks likeTkinter,wxPython, or .NET Windows Forms withIronPython take advantage of lambda functions for mapping actions in response to UI events.

The naive Tkinter program below demonstrates the usage of alambda assigned to the command of theReverse button:

importtkinterastkimportsyswindow=tk.Tk()window.grid_columnconfigure(0,weight=1)window.title("Lambda")window.geometry("300x100")label=tk.Label(window,text="Lambda Calculus")label.grid(column=0,row=0)button=tk.Button(window,text="Reverse",command=lambda:label.configure(text=label.cget("text")[::-1]),)button.grid(column=0,row=1)window.mainloop()

Clicking the buttonReverse fires an event that triggers the lambda function, changing the label fromLambda Calculus tosuluclaC adbmaL*:

Both wxPython and IronPython on the .NET platform share a similar approach for handling events. Note thatlambda is one way to handle firing events, but a function may be used for the same purpose. It ends up being self-contained and less verbose to use alambda when the amount of code needed is very short.

To explore wxPython, check outHow to Build a Python GUI Application With wxPython.

Python Interpreter

When you’re playing with Python code in the interactive interpreter, Python lambda functions are often a blessing. It’s easy to craft a quick one-liner function to explore some snippets of code that will never see the light of day outside of the interpreter. The lambdas written in the interpreter, for the sake of speedy discovery, are like scrap paper that you can throw away after use.

timeit

In the same spirit as the experimentation in the Python interpreter, the moduletimeit provides functions to time small code fragments.timeit.timeit() in particular can be called directly, passing some Python code in a string. Here’s an example:

>>>fromtimeitimporttimeit>>>timeit("factorial(999)","from math import factorial",number=10)0.0013087529951008037

When the statement is passed as a string,timeit() needs the full context. In the example above, this is provided by the second argument that sets up the environment needed by the main function to be timed. Not doing so would raise aNameError exception.

Another approach is to use alambda:

>>>frommathimportfactorial>>>timeit(lambda:factorial(999),number=10)0.0012704220062005334

This solution is cleaner, more readable, and quicker to type in the interpreter. Although the execution time was slightly less for thelambda version, executing the functions again may show a slight advantage for thestring version. The execution time of thesetup is excluded from the overall execution time and shouldn’t have any impact on the result.

Monkey Patching

For testing, it’s sometimes necessary to rely on repeatable results, even if during the normal execution of a given software, the corresponding results are expected to differ, or even be totally random.

Let’s say you want to test a function that, at runtime, handlesrandom values. But, during the testing execution, you need to assert against predictable values in a repeatable manner. The following example shows how, with alambda function, monkey patching can help you:

fromcontextlibimportcontextmanagerimportsecretsdefgen_token():"""Generate a random token."""returnf'TOKEN_{secrets.token_hex(8)}'@contextmanagerdefmock_token():"""Context manager to monkey patch the secrets.token_hex    function during testing.    """default_token_hex=secrets.token_hexsecrets.token_hex=lambda_:'feedfacecafebeef'yieldsecrets.token_hex=default_token_hexdeftest_gen_token():"""Test the random token."""withmock_token():assertgen_token()==f"TOKEN_{'feedfacecafebeef'}"test_gen_token()

A context manager helps with insulating the operation of monkey patching a function from the standard library (secrets, in this example). The lambda function assigned tosecrets.token_hex() substitutes the default behavior by returning a static value.

This allows testing any function depending ontoken_hex() in a predictable fashion. Prior to exiting from the context manager, the default behavior oftoken_hex() is reestablished to eliminate any unexpected side effects that would affect other areas of the testing that may depend on the default behavior oftoken_hex().

Unit test frameworks likeunittest andpytest take this concept to a higher level of sophistication.

Withpytest, still using alambda function, the same example becomes more elegant and concise :

importsecretsdefgen_token():returnf'TOKEN_{secrets.token_hex(8)}'deftest_gen_token(monkeypatch):monkeypatch.setattr('secrets.token_hex',lambda_:'feedfacecafebeef')assertgen_token()==f"TOKEN_{'feedfacecafebeef'}"

With thepytestmonkeypatch fixture,secrets.token_hex() is overwritten with a lambda that will return a deterministic value,feedfacecafebeef, allowing to validate the test. The pytestmonkeypatch fixture allows you to control the scope of the override. In the example above, invokingsecrets.token_hex() in subsequent tests, without using monkey patching, would execute the normal implementation of this function.

Executing thepytest test gives the following result:

$pytesttest_token.py-v============================= test session starts ==============================platform linux -- Python 3.7.2, pytest-4.3.0, py-1.8.0, pluggy-0.9.0cachedir: .pytest_cacherootdir: /home/andre/AB/tools/bpython, inifile:collected 1 itemtest_token.py::test_gen_token PASSED                                     [100%]=========================== 1 passed in 0.01 seconds ===========================

The test passes as we validated that thegen_token() was exercised, and the results were the expected ones in the context of the test.

Map

The built-in functionmap() takes a function as a first argument and applies it to each of the elements of its second argument, aniterable. Examples of iterables are strings, lists, and tuples. For more information on iterables and iterators, check outIterables and Iterators.

map() returns an iterator corresponding to the transformed collection. As an example, if you wanted to transform a list of strings to a new list with each string capitalized, you could usemap(), as follows:

>>>list(map(lambdax:x.capitalize(),['cat','dog','cow']))['Cat', 'Dog', 'Cow']

You need to invokelist() to convert the iterator returned bymap() into an expanded list that can be displayed in the Python shell interpreter.

Using a list comprehension eliminates the need for defining and invoking the lambda function:

>>>[x.capitalize()forxin['cat','dog','cow']]['Cat', 'Dog', 'Cow']

Filter

The built-in functionfilter(), another classic functional construct, can be converted into a list comprehension. It takes apredicate as a first argument and an iterable as a second argument. It builds an iterator containing all the elements of the initial collection that satisfies the predicate function. Here’s an example that filters all the even numbers in a given list of integers:

>>>even=lambdax:x%2==0>>>list(filter(even,range(11)))[0, 2, 4, 6, 8, 10]

Note thatfilter() returns an iterator, hence the need to invoke the built-in typelist that constructs a list given an iterator.

The implementation leveraging the list comprehension construct gives the following:

>>>[xforxinrange(11)ifx%2==0][0, 2, 4, 6, 8, 10]

Reduce

Since Python 3,reduce() has gone from a built-in function to afunctools module function. Asmap() andfilter(), its first two arguments are respectively a function and an iterable. It may also take an initializer as a third argument that is used as the initial value of the resulting accumulator. For each element of the iterable,reduce() applies the function and accumulates the result that is returned when the iterable is exhausted.

To applyreduce() to a list of pairs and calculate the sum of the first item of each pair, you could write this:

>>>importfunctools>>>pairs=[(1,'a'),(2,'b'),(3,'c')]>>>functools.reduce(lambdaacc,pair:acc+pair[0],pairs,0)6

A more idiomatic approach using agenerator expression, as an argument tosum() in the example, is the following:

>>>pairs=[(1,'a'),(2,'b'),(3,'c')]>>>sum(x[0]forxinpairs)6

A slightly different and possibly cleaner solution removes the need to explicitly access the first element of the pair and instead use unpacking:

>>>pairs=[(1,'a'),(2,'b'),(3,'c')]>>>sum(xforx,_inpairs)6

The use of underscore (_) is a Python convention indicating that you can ignore the second value of the pair.

sum() takes a unique argument, so the generator expression does not need to be in parentheses.