Once upon a time in PythonLand, there lived a group of workers known as functions. Each one had a name, a job, and a clearly defined block of instructions. But there came a time when Python programmers needed quick, one-time helpers—tiny workers who could perform small tasks and disappear without ceremony.

Thus, the lambda function was born.

Lambda functions are also called anonymous functions because they do not need a name like traditional functions (def my_function():). They’re short, they do one thing only, and they’re often used just once—kind of like sending a message with a paper airplane rather than delivering a whole package.

Let’s look at how they work.

🚀 Syntax of a Lambda Function

lambda arguments: expression

Just like a regular function, you pass in arguments. But instead of writing a whole block of code, the function body is just one expression—that’s all.

Important: That body must be an expression (something that returns a value), not a statement like a for loop or print().

🧪 Simple Example: Double a Number

Here’s a normal function:

def double(x):
    return x * 2

Here’s the same logic with a lambda:

lambda x: x * 2

But how do we use it? You can assign it to a variable:

double = lambda x: x * 2
print(double(4))  # Output: 8

Cool, right?

🧮 Lambda with Multiple Arguments

add = lambda a, b: a + b
print(add(3, 5))  # Output: 8

You can do multiplication, string formatting, and even conditional expressions—all in one line.

đź”— Real Power: Using Lambda with Built-in Functions

Lambdas shine best when paired with Python’s built-in higher-order functions like map(), filter(), and reduce().

1. map(): Transform Each Item in a List

nums = [1, 2, 3, 4]
doubled = list(map(lambda x: x * 2, nums))
print(doubled)  # Output: [2, 4, 6, 8]

2. filter(): Keep Only Certain Items

nums = [1, 2, 3, 4]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)  # Output: [2, 4]

3. reduce(): Reduce a List to a Single Value

from functools import reduce
nums = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, nums)
print(product)  # Output: 24

⚠️ When Not to Use Them?

  • ❌ When the logic is complex—stick with def.
  • ❌ When debugging—you can’t name or trace a lambda easily.
  • ❌ When readability is important—especially for beginners.

đź“ť Practice Time!

  1. Convert to Lambda: Rewrite the following as a lambda:

    def square(n):
    return n ** 2

  2. What will this print?

    triple = lambda x: x * 3
print(triple(5))

  3. Use with filter(): Write a lambda inside filter() that returns only odd numbers from [10, 15, 20, 25, 30].

  4. True or False: Lambda functions can have more than one expression in their body.

  5. Why Not Lambda?: What’s the downside of using a lambda for complex logic?

<
Previous Post
🪟 JavaScript Modals: When the Browser Talks Back
>
Next Post
🧳 Python Nested Functions: A Function Within a Function