Why Python’s Lambda Functions Survive: History, Usage, and Controversy

Python supports lambda anonymous functions, defined by the BNF syntax: lambda_expr ::= "lambda" [parameter_list] ":" expression In Chinese notation: lambda 参数序列:表达式.

This provides a concise way to define a function; translated to a regular function it looks like:

def <lambda>(parameter_list):
    return expression

In Python, a lambda is a function that can take multiple parameters and returns a single expression.

Its main advantage is a one‑line definition without naming the function or needing indentation.

However, lambda functions can make code harder to read and are sometimes misused; even Guido van Rossum, Python’s creator, once considered removing them.

Typical uses combine lambda with higher‑order functions such as map(), filter(), reduce(), and sorted(), which all accept other functions as arguments.

Examples:

my_list = [3,1,5,4,10]

# add 1 to each element
list(map(lambda i: i+1, my_list))

# filter elements less than 10
list(filter(lambda i: i<10, my_list))

# sum elements using reduce
from functools import reduce
reduce(lambda i,j: i+j, my_list, 10)

# sort a dict by value
my_dict = {'a':3,'b':1,'c':5,'d':4}
sorted(my_dict.items(), key=lambda item: item[1])

Key usage patterns for lambda functions:

Appears wherever a function is needed.

Suitable for simple, one‑off functionality.

Typically not reusable elsewhere.

Usually used as an argument to another function rather than standalone.

Problems with lambda

Lambda is limited to a single expression; it cannot contain statements, multi‑line logic, conditional branches, or try‑except blocks, which many consider a “crippled” design.

Some have proposed extending the syntax (e.g., lambda args::suite) to allow multi‑line bodies, but Guido rejected these ideas, emphasizing simplicity and Pythonic design.

Guido argued that adding complex syntax would harm readability and that the same functionality can be achieved with named functions or comprehensions.

Why Guido considered removing lambda

In 2005 he suggested dropping lambda, reduce, map, and filter, citing reasons such as:

Confusion for users unfamiliar with Lisp.

Unnecessary choice leading to complexity.

Redundancy with list comprehensions and generator expressions.

Reduce being hard to understand compared to explicit loops.

These arguments align with the Zen of Python principle that there should be one obvious way to do something.

Ultimately, for backward compatibility and community preference, lambda remained, though attempts to extend it were blocked.

Understanding this history deepens our appreciation of Python’s design philosophy.