res = 0

for i in range(len(numbers)): # use indexing res = res + numbers[i]

print res

Whilst that produces the same result in this case it is not always so straightforward. What reduce actually does is call the supplied function passing the first two members of the sequence and replaces the second item with the result. In other words a more accurate representation of reduce is like this:

L = numbers[:] # make a copy of original while len(L) >= 2:

i,j = L[0],L[1] # use tuple assignment L = [i+j] + L[2:]

print L[0]

Once more we see the FP technique reducing the complexity of the code by avoiding the need for an indented block of code.

lambda

One feature you may have noticed in the examples so far is that the functions passed to the FP functions tend to be very short, often only a single line of code. To save the effort of defining lots of very small functions Python provides another aid to FP - lambda

Lambda is a term used to refer to an anonymous function, that is a block of code which can be executed as if it were a function but without a name. Lambdas can be defined anywhere within a program that a legal Python expression can occur, which means we can use them inside our FP functions.

A Lambda looks like this:

lambda <aParameterList> : <a block of code using the parameters>

Thus the add function above could be rewritten as:

add = lambda i,j: i+j

And we can avoid the definition line completely by creating the lambda within the call to reduce, like so:

print reduce(lambda i,j:i+j, numbers)

Similarly we can rewrite our map and filter examples like so:

L = map(lambda i: i, spam) print L

L = filter(lambda i: (i%2 != 0), numbers) print L

Other constructs

Of course while these functions are useful in their own right they are not suffiecient to allow a full FP style within Python. The control structures of the language also need to be altered, or at least substituted, by an FP approach. One way to achieve this is by applying a side effect of how Python evaluates boolean expressions.

Short Circuit evaluation

Because Python uses short circuit evaluation of boolean expressions certain properties of these expressions can be exploited. To recap on short-circuit evaluation: when a boolean expression is evaluated the evaluation

96

starts at the left hand expression and proceeds to the right, stopping when it is no longer necessary to evaluate any further to determine the final outcome.

Taking some specific examples let's see how short circuit evaluation works:

>>> def TRUE():

... print 'TRUE'

... return 1 # boolean TRUE

...

>>>def FALSE():

... print 'FALSE'

... return 0 # boolean FALSE

...

First we define two functions that tell us when they are beuing executed and return the value of their names. Now we use these to explore how bopolean expressions are evaluated:

>>>print TRUE() and FALSE() TRUE

FALSE 0

>>>print TRUE() and TRUE() TRUE

TRUE 1

>>>print FALSE() and TRUE() FALSE

0

>>>print TRUE() or FALSE() TRUE

1

>>>print FALSE() or TRUE() FALSE

TRUE 1

>>>print FALSE() or FALSE() FALSE

FALSE 0

Notice that only IF the first part of an AND expression is TRUE then and only then will the second part be evaluated. If the first part is False then the second part will not be evaluated since the expressionas a whole cannot be true.

Likewise in an OR based expression if the first part is True then the second part need not be evaluated since the whole must be true.

We can use these properties to reproduce branching like behaviour. For example suppose we have a piece of code like the following:

if TRUE(): print "It is True" else: print "It is False"

We can replace that with the FP style construct:

V = (TRUE() and "It is True") or ("It is False") print V

97