# I sing the praises of lambda, my friend and savior!

Steven Bethard steven.bethard at gmail.com
Mon Oct 11 20:30:21 CEST 2004

```On Mon, 11 Oct 2004 13:54:29 -0400, Clark C. Evans <cce at clarkevans.com> wrote:
> By this logic, one would make a function,
>
>      def eval(x):
>          return a*x*x+b*x+c
>
> and use quadratic(0,2,1,x) where you'd otherwise write (2*x+1)?

No.  Sorry, I obviously wasn't clear here.  The suggestion made to me
was to generalize the function only as much as necessary so that it
could apply to multiple statements *in my code*.  So, while I would
write your 'quadratic' function if my code contained statements like:

func(arg, lambda x: 2*x**2 + 2*x+1)
func(arg, lambda x: 2*x+2)
func(arg, lambda x: 3*x**2+1)

where I truly need the a, b, and c parameters, if my code instead looked like:

func(arg1, lambda x: 2*x+1)
func(arg2, lambda x: 2*x+1)

then I would definitely write it as:

def times2plus1(x):
return 2*x+1
func(arg1, times2plus1)
func(arg2, times2plus1)

Note that the full 'quadratic' example requires a more verbose, nested
function approach because we want partial function application.  We
could also rewrite the code as something like:

def quadratic(a, b, c, x):
return a*x**2+b*x+c
func(arg, partial(quadratic, 0, 2, 1))

using partial function application (check the Cookbook for implementation).

Yes, it's still more verbose.  But if you have 30 instances of

func(arg, lambda x: a*x**2+b*x+c)

each with different a's, b's and c's, and you realize later that these
should all be using a*x**2-b*x-c instead, it's much quicker to fix the
one function than the 30.  =)  On the other hand, if you have only one
instance, I can certainly understand the reluctance.

Out of curiosity, is this quadratic example a real example from your
code, or were you just making this one up?  Just so you know where I
was coming from, the code I changed went from:

self.assertRaises(IndexError, lambda t: t[-10])
self.assertRaises(IndexError, lambda t: t[9])
...

to

def getitem(obj, item):
return obj[item]
self.assertRaises(IndexError, getitem, tree, -10)
self.assertRaises(IndexError, getitem, tree, 9)
...

Note that I had enough assertRaises calls to probably justify this
change -- if I decide later there's something more I should do in
getitem, I can change it in only one place.

> That said, a simple conditional expression would be delightful, as
> I often use mappings (see above) for this sort of logic.

Yeah, I wholeheartedly agree.  (Though of course this one has been
beaten into the ground already, so I won't hold my breath.)

Steve
--
You can wordify anything if you just verb it.
- Bucky Katt, Get Fuzzy

```