I think Python’s lambda is probably somewhat confusing because of its limitations. For example, you can write the Y Combinator in Python but the limitations of lambda in Python make that a very difficult bit of code to read and understand. In languages with better lambda support (like Javascript, Scheme, Lisp, etc) such concepts are pretty natural.

Lambda is pretty useful for encapsulating procedures related to a single function without exposing them in the namespace of the module. Python’s conventions for working around this limitation are pretty ugly, IMO. One either prefixes such supporting “functions” with an underscore or they exclude them from the __all__ special module-level attribute (otherwise they create more classes or just let such trivial bits of code float freely in their module name space).

Lambda is also pretty useful for expressing alternate control flows irrc, but I think that’s something you can read about in the Seasoned Schemer.

>> But lambda is so much more than just a keyword in Python for creating anonymous function objects!

I agree. I focused on lambda-the-Python-progamming-language-keyword because that (and its documentation) was the source of the problems that I wanted to address. In footnote 3, I made a nod to situating that topic in a larger context. But, well, Alonzo Church was definitely out-of-scope.

But James is right. And “lambda — more than a Python keyword” would be a great topic for a post of its own. Unfortunately, I’m not competent to write it.

I know that the word “lambda” can refer to a lot of different things.

• lambda-in-Python, i.e. lambda-the-Python-progamming-language-keyword
• lambda-in-Lisp
• lambda-the-programming-language-concept
• lambda-the-logical-concept
• … etc. etc. …

And I’ve found a few articles:

• In wikipedia, what you really want to look at is the article on anonymous functions. And maybe the article on first-class functions.
• Surprisingly, the Wikipedia article on lambda in programming languages is very weak.
• Wikipedia has an article on the lambda calculus that will likely be too far afield to be interesting or helpful for most programmers.
• For the really hardy, there is an article on the Y combinator.

But those are encyclopedia articles. Pretty dry. What I’d really like to learn more about is what makes programmers like James, who use lambda on a regular basis, love lambda.

So… are there any readers out there who might have recommendations and/or links to books, articles, blog postings, tutorials, or web sites that would help those of us (the ones familiar with lambda only in the context of Python) to see lambda in a larger context? If so, would you be willing to share them? You can code raw HTML into a comment, so you can code an HTML link by doing something that looks like this:

There is a great introduction to lambda for programmers at <a href="....">Lambdas R Us</a>

command=lambda: self.printNum(44)) # calls self.printNum with an extra argument (44)

For this, functools provides a function that provides the same functionality: partial

command=partial(self.printNum, 44)

This is less general than lambda: any partial can be rewritten as a lambda statement. partial(func, *args, **kargs) is simply lambda *args, **kargs: func(*args, **kargs). However, partial does not depend on a special syntax that is considered difficult to understand.

IMHO, the remaining use cases for lambda are so limited that ‘they’ might as well remove it from the language.

The alternative would be changing function (and class?) definitions to become proper expressions, eg rewriting def function(args) as function = def(args), but that would have very serious implications for the whole language and might make it more difficult to read/learn rather than easier.

class Fraction:
     def __init__(self, num,denom):
        self.num = num
        self.denom = denom

fractions = [Fraction(1,2), Fraction(2,3), Fraction (5,7)]
sum_num = reduce(fractions, lambda x,y:x.num+y.num, 0)

Of course this is a contrived example (why would you need to sum numerators?), but this style of usage is most common for me.

While lambda can be confusing for beginning programmers, especially those without a mathematics background, is there any risk in exposing them to the bigger picture in an introductory tutorial? Maybe a footnote?

I just love lambda and wish it was better supported in Python (even though it will probably never be).

Nice article!