[Tutor] Why use lambda?

[Danny Yoo]

> What can lambda do that normal function definitions cannot?
> Is it quicker to execute/less memory intensive?
> Or is it just quicker to type and easier to think about?

Notational convenience.  Think about how, in arithmetic expressions,
how we're not forced to give explicit names to all the subexpressions:

#########################
def hypotenuse(a, b):
    return ((a * a) + (b * b))**0.5
#########################

Imagine a world where we have to give explicit names to all of the
subexpressions:

###################
def hypotenuse(a, b):
    tmp1 = a * a
    tmp2 = b * b
    tmp3 = tmp1 + tmp2
    tmp4 = tmp3**0.5
    return tmp4
####################

Does this look funny to you?  Why?



Sometimes we don't care what something is named: we just want to use
the value.  lambda's use is motivated by the same idea: sometimes, we
want to use a function value without having to give a name. Here's a
toy example.

####################################
def deepmap(f, datum):
    """Deeply applies f across the datum."""
    if type(datum) == list:
        return [deepmap(f, x) for x in datum]
    else:
        return f(datum)
####################################

If we wanted to apply a squaring on all the numbers in the nested list
(while still maintaining the nested structure):

    [42, 43, [44, [45]]]

then we can use deepmap by feeding in a square function to it.

##############################
def square(x):
    return x * x

deepmap(square, [42, 43, [44, [45]]])
###############################

An alternative way to express the above is:

    deepmap(lambda x: x *x, [42, 43, [44, [45]]])

Here, we avoid having to first give a name to the function value we're
passing to deepmap.