Python Lambda Functions

3Python Lambda: explained step by step

A lambda is a small function without a name, written as a single expression. In day-to-day code you meet it in one place above all: as a short throwaway function that you hand to something else, such as sorted() or max(), to tell it how to do its job.

A lambda is a def squeezed into one line

These two forms build the same kind of function object. The lambda is shown inside brackets only so that it can be called on the spot for this demo; normally you would pass it somewhere instead.

def total(price, qty):
    return price * qty

print(total(4, 3))
print((lambda price, qty: price * qty)(4, 3))
print(type(lambda: 0).__name__)

The pattern is lambda parameters: expression. The parameters are written like those of a def, but without brackets. There is no return keyword: whatever the expression evaluates to is what the function gives back.

One expression, no statements

The body of a lambda has to be a single expression: arithmetic, comparisons, function calls, f-strings, even a list comprehension. It cannot contain statements, so no assignment, no return, no for or while block, no try. A lambda also has no place for a docstring. The moment you need a second line, write a normal def.

The everyday job: key functions

sorted(), min() and max() accept a key= function. Python calls it once for every item, and the value it returns decides the order. You get your original items back, just arranged by that value. A lambda is perfect here because the rule is tiny and used once.

students = [("Asha", 82), ("Ben", 91), ("Cara", 77)]
print(sorted(students, key=lambda s: s[1]))
print(max(students, key=lambda s: s[1]))
print(min(students, key=lambda s: s[1])[0])

words = ["banana", "kiwi", "apple", "pear"]
print(sorted(words, key=lambda w: (len(w), w)))

Each s is one whole tuple, so s[1] is the score. Returning a tuple such as (len(w), w) sorts by length first and uses the word itself to break ties. Add reverse=True for descending order.

Choosing inside a lambda

An if statement is not allowed, but the one-line conditional expression, value_if_true if condition else value_if_false, is. It always needs its else.

tasks = [
    {"name": "write report", "urgent": False},
    {"name": "fix login bug", "urgent": True},
    {"name": "book travel", "urgent": False},
]
ordered = sorted(tasks, key=lambda t: (0 if t["urgent"] else 1, t["name"]))
print([t["name"] for t in ordered])

Urgent tasks get the sort value 0, so they come first. The rest are ordered alphabetically.

Functions are values: callbacks and operation tables

In Python a function can be stored in a variable, a list or a dictionary and passed to other functions. Code that receives a function and calls it later is using a callback. A dictionary of lambdas makes a neat lookup table that replaces a long if/elif chain.

operations = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
    "mul": lambda a, b: a * b,
    "div": lambda a, b: a / b if b != 0 else None,
}
for name in ["add", "mul", "div"]:
    print(name, operations[name](12, 4))
print(operations["div"](5, 0))

def apply_twice(func, value):
    return func(func(value))

print(apply_twice(lambda text: text + "!", "hey"))

The late-binding gotcha

A lambda looks up the variables from outside only when it is called, not when it is created. Build several lambdas in a loop and they all see the loop variable's final value:

funcs = []
for n in [1, 2, 3]:
    funcs.append(lambda: n * 10)
print([f() for f in funcs])

funcs = []
for n in [1, 2, 3]:
    funcs.append(lambda n=n: n * 10)
print([f() for f in funcs])

The first list prints [30, 30, 30] because the loop has finished and n is 3 by the time any lambda runs. The fix is n=n: a default value is evaluated immediately, when the lambda is created, so each function keeps its own copy.

Lambda or def?

Use a lambda when the function is short, used once and written exactly where it is needed. Use a def when it is longer than one comfortable line, when you use it in more than one place, or when you want a name. PEP 8, Python's style guide, specifically discourages writing square = lambda x: x * x: it gives you nothing over a def, and the function is less helpful when something goes wrong.

square = lambda x: x * x

def cube(x):
    return x ** 3

print(square.__name__, cube.__name__)

The lambda calls itself <lambda>, so in a traceback you cannot tell which one failed. Also skip the lambda when a built-in already does the job: key=len is clearer than key=lambda w: len(w).