Lambda Functions

Lambda function

A lambda function is a small, anonymous function, anonymous meaning it has no name. It is defined inline, on the spot, and typically used for short, throwaway logic that doesn’t warrant a full function definition. The concept comes from lambda calculus, a mathematical framework for expressing computation through function abstraction, developed by Alonzo Church in the 1930s. It is one of the theoretical foundations of functional programming.

Lambda functions are a common feature across many languages, though the syntax varies:

• Python: lambda x: x ** 2
• JavaScript: x => x ** 2
• Java: x -> x * x
• Haskell: \x -> x ^ 2

The idea is always the same: a compact, nameless function defined in place.

In Python, a lambda is a single-expression, anonymous function. It behaves exactly like a regular def function but is written in one line and returns its expression implicitly, no return keyword needed:

Lambda function

lambda <arguments> : <expression>

Examples

# Syntax: lambda arguments: expression
square = lambda x: x ** 2
add    = lambda x, y: x + y
greet  = lambda name: f"Hello, {name}!"

print(square(5))        # 25
print(add(3, 4))        # 7
print(greet("Alice"))   # Hello, Alice!

Where Lambdas Shine

Their real power is as inline arguments to higher-order functions, where defining a full named function would feel unnecessarily heavy:

# Input definition
numbers = [3, 1, 4, 1, 5, 9, 2]

# Sorting by a custom key
sorted_nums = sorted(numbers, key=lambda x: -x)        # descending
print(sorted_nums)   # [9, 5, 4, 3, 2, 1, 1]

# Filtering evens
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)         # [4, 2]

# Doubling each value
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)       # [6, 2, 8, 2, 10, 18, 4]

Lambda vs def — When to Use Which

	lambda	def
Has a name	❌ Anonymous	✅ Named
Number of expressions	One only	Unlimited
Can include statements	❌ No	✅ Yes
Reusability	Low — inline use	High — defined once, used anywhere
Readability	Good for simple logic	Better for complex logic

Rule of thumb

If your lambda is getting complicated or you find yourself reusing it, convert it into a proper def function. Lambdas are best kept short and situational.

Advantages

# Syntax: lambda arguments: expression
square    = lambda x: x ** 2
add       = lambda x, y: x + y
greet     = lambda name: f"Hello, {name}!"

print(square(5))        # 25
print(add(3, 4))        # 7
print(greet("Alice"))   # Hello, Alice!


# Lambdas shine as inline arguments
data = [("Alice", 30), ("Bob", 25), ("Carol", 35)]

# Sort by age
sorted_data = sorted(data, key=lambda person: person[1])
print(sorted_data)      # [('Bob', 25), ('Alice', 30), ('Carol', 35)]

# Sort by name length, then alphabetically
sorted_data = sorted(data, key=lambda p: (len(p[0]), p[0]))

# With filter, map, reduce
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens   = list(filter(lambda x: x % 2 == 0, nums))
squared = list(map(lambda x: x ** 2, nums))
print(evens)            # [2, 4, 6, 8, 10]
print(squared)          # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Limitations

# Limitation — lambdas are single expressions only
# Use def for anything complex
# ❌ Hard to read
process = lambda x: x**2 if x > 0 else -x if x < 0 else 0

# ✅ Much clearer as a named function
def process(x):
    if x > 0:   return x ** 2
    if x < 0:   return -x
    return 0