Skip to content

Python Lambda Functions — Knowledge Base Article

Source: Tech With Tim — YouTube tutorial URL: https://www.youtube.com/watch?v=HQNiSfb795A Tags: #python #lambda #functional-programming #beginner

1. What Is a Lambda Function?

A lambda function is a small, anonymous, inline function defined in a single expression.

# Lambda form:     lambda params: expression
add_one = lambda x: x + 1
print(add_one(1))  # → 2
  • Anonymous: does not require a name (though you can assign it to a variable).
  • Single expression: the expression after the colon is automatically returned — no return keyword needed.
  • Any number of parameters: comma-separated like a normal function.

Equivalent named function

def add_one(x):
    return x + 1

Both definitions above produce the same result. The lambda is preferred when you only need the function once and want to keep the definition local.

2. Why Use Lambdas?

Use lambdas when you need to pass a short, one-off function as an argument to another function — typically map(), filter(), sorted(), or reduce().

Rule of thumb: if the logic fits on one line and you won't reuse the function elsewhere, use a lambda.

3. Common Use Cases

3.1 map() — Apply a function to every element

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
squared = list(map(lambda x: x ** 2, numbers))
# → [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Without a lambda you'd need a separate def square(x): return x**2, which is redundant if you only use it here.

3.2 filter() — Keep elements that satisfy a condition

evens = list(filter(lambda x: x % 2 == 0, numbers))
# → [2, 4, 6, 8, 10]

The lambda returns True for even numbers → those are kept; False → rejected.

3.3 sorted() — Custom sort key

data = [(1, 'c'), (2, 'a'), (3, 'b')]
sorted_by_letter = sorted(data, key=lambda x: x[1])
# → [(2, 'a'), (3, 'b'), (1, 'c')]

The key function extracts the second element (index 1) from each tuple, and Python sorts by that value.

Multi-level sort (secondary key on tie):

sorted(data, key=lambda x: (x[1], x[0]))

3.4 reduce() — Fold an iterable to a single value

from functools import reduce

numbers = [1, 2, 3, 4, 5]
total = reduce(lambda acc, x: acc + x, numbers)
# → 15

How it works step-by-step: 1. acc = 1 (first element), x = 2 → return 3 2. acc = 3, x = 3 → return 6 3. acc = 6, x = 4 → return 10 4. acc = 10, x = 5 → return 15

Find the maximum with reduce:

maximum = reduce(lambda acc, x: acc if acc > x else x, numbers)
# → 5

4. Advanced / Oddball Syntax

Immediately Invoked Lambda

You can define and call a lambda on the same line (valid Python, but rarely practical):

result = (lambda x, y: x + y)(3, 5)
# → 8

The function is defined, then called immediately with (3, 5). Technically valid — just don't do it in production code without a good reason.

5. When NOT to Use a Lambda

Use def (named function) when... Use lambda when...
Logic spans multiple lines Logic fits one expression
You need docstrings / annotations It's a throwaway callback
The function is reused in several places Used once as an argument
Debugging — named functions have clearer tracebacks The function is trivial (< 80 chars)

6. Quick Reference

Syntax lambda <params>: <expression>
Parameters Any number (zero, one, many, defaults, *args, **kwargs)
Return The expression value (implicit)
Restrictions Single expression only — no statements (return, if/elif blocks, loops, assert)
Common friends map(), filter(), sorted(key=...), reduce()
Module needed for reduce from functools import reduce

7. Summary

  1. Lambdas are inline anonymous functions — one expression, auto-return.
  2. Use them when passing a simple one-off function to map, filter, sorted, or reduce.
  3. Anything complex → use def. Lambdas trade readability for conciseness; don't overuse them.