पायथन लैम्ब्डा फ़ंक्शंस संपूर्ण गाइड 2026: उनका उपयोग कब और कैसे करें

# Syntax: lambda arguments: expression
# Single expression, no return statement needed, no statements (only expressions)

# Named function
def square(x):
    return x ** 2

# Equivalent lambda
square = lambda x: x ** 2
print(square(5))  # 25

# Multiple arguments
add = lambda x, y: x + y
print(add(3, 4))  # 7

# Default argument
greet = lambda name, greeting="Hello": f"{greeting}, {name}!"
print(greet("Alice"))         # "Hello, Alice!"
print(greet("Bob", "Hi"))     # "Hi, Bob!"

# Ternary in lambda
abs_val = lambda x: x if x >= 0 else -x
sign = lambda x: "positive" if x > 0 else "negative" if x < 0 else "zero" 

# sorted() — most common use case
users = [
    {"name": "Carol", "age": 35, "score": 9.1},
    {"name": "Alice", "age": 30, "score": 8.5},
    {"name": "Bob", "age": 25, "score": 7.2},
]

# Sort by age
by_age = sorted(users, key=lambda u: u["age"])

# Sort by score descending
by_score_desc = sorted(users, key=lambda u: u["score"], reverse=True)

# Sort by multiple fields (name desc, then age asc)
multi_sort = sorted(users, key=lambda u: (-u["score"], u["name"]))

# max/min with key
oldest = max(users, key=lambda u: u["age"])
best_score = max(users, key=lambda u: u["score"])

# map() — transform each element
names = list(map(lambda u: u["name"], users))
scores_doubled = list(map(lambda u: u["score"] * 2, users))

# filter() — keep matching elements
adults = list(filter(lambda u: u["age"] >= 30, users))

# Combined
result = sorted(
    filter(lambda u: u["age"] >= 30, users),
    key=lambda u: u["score"],
    reverse=True
)

from functools import reduce

# Process order data
orders = [
    {"product": "Widget", "price": 9.99, "qty": 3, "status": "completed"},
    {"product": "Gadget", "price": 24.99, "qty": 1, "status": "pending"},
    {"product": "Doohickey", "price": 4.99, "qty": 10, "status": "completed"},
]

# Total revenue from completed orders
revenue = sum(
    o["price"] * o["qty"]
    for o in orders
    if o["status"] == "completed"
)

# Sort by total value
sorted_orders = sorted(
    orders,
    key=lambda o: o["price"] * o["qty"],
    reverse=True
)

# Group by status using dict
from itertools import groupby

sorted_by_status = sorted(orders, key=lambda o: o["status"])
grouped = {
    status: list(group)
    for status, group in groupby(sorted_by_status, key=lambda o: o["status"])
}

# defaultdict with lambda
from collections import defaultdict
inventory = defaultdict(lambda: {"qty": 0, "locations": []})
inventory["Widget"]["qty"] += 10

# BAD: complex logic in lambda (unreadable)
process = lambda x: x * 2 if x > 0 else (x * -1 if x < 0 else 0)

# GOOD: named function for complex logic
def process(x: int) -> int:
    if x > 0: return x * 2
    if x < 0: return x * -1
    return 0

# BAD: lambda just calls another function
result = sorted(items, key=lambda x: str(x))

# GOOD: use function reference directly
result = sorted(items, key=str)

# BAD: assigning lambda to variable (just use def)
multiply = lambda x, y: x * y

# GOOD: named function (more debuggable, has proper __name__)
def multiply(x: int, y: int) -> int:
    return x * y

# GOOD use cases for lambda:
# - key= in sorted/max/min/groupby
# - One-off transformations in map/filter
# - When the logic is genuinely simple (< 1 line)
# - Callbacks in GUI/event frameworks

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# map + lambda (functional style)
doubled = list(map(lambda x: x * 2, data))

# List comprehension (preferred in Python)
doubled = [x * 2 for x in data]

# filter + lambda
evens = list(filter(lambda x: x % 2 == 0, data))

# List comprehension (preferred)
evens = [x for x in data if x % 2 == 0]

# When to choose:
# Lambda+map: when you have an existing function to pass
names = list(map(str.upper, ["alice", "bob"]))  # no lambda needed!
# List comprehension: when creating new expressions