Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Complete guide to Python lambda functions — syntax, use cases, usage with map/filter/sorted, and comparison with regular functions. Learn with practical examples.
Lambda is an anonymous function — a small function without a name that is written in a single line. Small task, small function!
1️⃣ Basic Lambda Syntax
Example
# ─────────────────────────────────────
# Regular function vs Lambda
# ─────────────────────────────────────
# Regular function
def square_def(x):
return x ** 2
# Lambda equivalent
square_lambda = lambda x: x ** 2
# Both do the same thing
print(square_def(5)) # 25
print(square_lambda(5)) # 25
# Type check
print(type(square_def)) # <class 'function'>
print(type(square_lambda)) # <class 'function'>
# ─── Zero arguments ───
greet = lambda: "Namaste! 🙏"
print(greet()) # Namaste! 🙏
# ─── One argument ───
double = lambda x: x * 2
print(double(7)) # 14
# ─── Two arguments ───
add = lambda a, b: a + b
print(add(3, 4)) # 7
# ─── Three arguments ───
full_name = lambda f, m, l: f"{f} {m} {l}"
print(full_name("Raj", "Kumar", "Sharma")) # Raj Kumar Sharma
Code example
# OUTPUT:
25
25
<class 'function'>
<class 'function'>
Namaste! 🙏
14
7
Raj Kumar Sharma2️⃣ Lambda with Conditions
Example
# ─────────────────────────────────────
# Lambda mein ternary operator
# ─────────────────────────────────────
# Even/Odd check
check_even = lambda n: "Even ✅" if n % 2 == 0 else "Odd ❌"
print(check_even(4)) # Even ✅
print(check_even(7)) # Odd ❌
# Absolute value
absolute = lambda x: x if x >= 0 else -x
print(absolute(-15)) # 15
print(absolute(8)) # 8
# Max of two numbers
maximum = lambda a, b: a if a > b else b
print(maximum(10, 20)) # 20
print(maximum(30, 15)) # 30
# Grade lambda
grade = lambda p: "A+" if p>=90 else ("A" if p>=80 else ("B" if p>=70 else "C"))
for score in [95, 83, 71, 55]:
print(f" Score {score}: {grade(score)}")
| Score 95 | A+ |
| Score 83 | A |
| Score 71 | B |
| Score 55 | C |
3️⃣ Lambda with map() — Transformation
Example
# ─────────────────────────────────────
# map() — har element pe function apply karo
# map(function, iterable)
# ─────────────────────────────────────
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Squares
squares = list(map(lambda x: x**2, numbers))
print(f"Squares : {squares}")
# Celsius to Fahrenheit
temps_c = [0, 20, 37, 100]
temps_f = list(map(lambda c: (c * 9/5) + 32, temps_c))
print(f"Celsius : {temps_c}")
print(f"Fahrenheit: {temps_f}")
# String manipulation
names = ["rahul", "priya", "amit", "sunita"]
capitalized = list(map(lambda s: s.capitalize(), names))
print(f"Original : {names}")
print(f"Capitalized: {capitalized}")
# Prices with discount
prices = [100, 250, 500, 1000, 75]
discounted = list(map(lambda p: round(p * 0.9, 2), prices))
print(f"\nOriginal prices : {prices}")
print(f"After 10% off : {discounted}")
| Squares | [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] |
| Celsius | [0, 20, 37, 100] |
| Fahrenheit | [32.0, 68.0, 98.6, 212.0] |
| Original | ['rahul', 'priya', 'amit', 'sunita'] |
| Capitalized | ['Rahul', 'Priya', 'Amit', 'Sunita'] |
| Original prices | [100, 250, 500, 1000, 75] |
| After 10% off | [90.0, 225.0, 450.0, 900.0, 67.5] |
4️⃣ Lambda with filter() — Filtering
Example
# ─────────────────────────────────────
# filter() — keep only elements that pass the condition
# filter(function, iterable)
# ─────────────────────────────────────
numbers = list(range(1, 21))
print(f"All numbers: {numbers}")
# Even numbers
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(f"Even only : {evens}")
# Numbers divisible by 3
div_3 = list(filter(lambda x: x % 3 == 0, numbers))
print(f"Div by 3 : {div_3}")
# Positive numbers from mixed list
mixed = [-5, -2, 0, 3, 7, -1, 8, 12, -9]
positives = list(filter(lambda x: x > 0, mixed))
print(f"\nMixed : {mixed}")
print(f"Positive: {positives}")
# Filter students who passed (marks >= 40)
students = [
{"name": "Anil", "marks": 72},
{"name": "Beena", "marks": 35},
{"name": "Chetan", "marks": 88},
{"name": "Divya", "marks": 28},
{"name": "Esha", "marks": 55},
]
passed = list(filter(lambda s: s["marks"] >= 40, students))
failed = list(filter(lambda s: s["marks"] < 40, students))
print("\n✅ Passed Students:")
for s in passed:
print(f" {s['name']}: {s['marks']}")
print("\n❌ Failed Students:")
for s in failed:
print(f" {s['name']}: {s['marks']}")
| All numbers | [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] |
| Even only | [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] |
| Div by 3 | [3, 6, 9, 12, 15, 18] |
| Mixed | [-5, -2, 0, 3, 7, -1, 8, 12, -9] |
| Positive | [3, 7, 8, 12] |
| Anil | 72 |
| Chetan | 88 |
| Esha | 55 |
| Beena | 35 |
| Divya | 28 |
5️⃣ Lambda with sorted() and sort() — Custom Sorting
Example
# ─────────────────────────────────────
# sorted() with lambda key
# ─────────────────────────────────────
# 1. List of tuples sort karo
employees = [
("Rahul", 45000),
("Priya", 62000),
("Amit", 38000),
("Sunita", 75000),
("Rohan", 55000),
]
# Sort by salary (ascending)
by_salary = sorted(employees, key=lambda emp: emp[1])
print("📈 Sorted by Salary (Low to High):")
for name, salary in by_salary:
print(f" {name:<10}: ₹{salary:,}")
# Sort by salary (descending)
by_salary_desc = sorted(employees, key=lambda emp: emp[1], reverse=True)
print("\n📉 Sorted by Salary (High to Low):")
for name, salary in by_salary_desc:
print(f" {name:<10}: ₹{salary:,}")
# 2. Dictionary list sort karo
products = [
{"name": "Laptop", "price": 65000, "rating": 4.5},
{"name": "Phone", "price": 25000, "rating": 4.8},
{"name": "Tablet", "price": 35000, "rating": 4.2},
{"name": "Watch", "price": 8000, "rating": 4.6},
]
# Sort by rating (best first)
by_rating = sorted(products, key=lambda p: p["rating"], reverse=True)
print("\n⭐ Products by Rating:")
for p in by_rating:
print(f" {p['name']:<10} ₹{p['price']:>7,} ⭐{p['rating']}")
# Sort by price
by_price = sorted(products, key=lambda p: p["price"])
print("\n💰 Products by Price:")
for p in by_price:
print(f" {p['name']:<10} ₹{p['price']:>7,} ⭐{p['rating']}")
| Amit | ₹38,000 |
| Rahul | ₹45,000 |
| Rohan | ₹55,000 |
| Priya | ₹62,000 |
| Sunita | ₹75,000 |
| Sunita | ₹75,000 |
| Priya | ₹62,000 |
| Rohan | ₹55,000 |
| Rahul | ₹45,000 |
| Amit | ₹38,000 |
6️⃣ Lambda with reduce() — Aggregation
Example
# ─────────────────────────────────────
# reduce() — reduce a list to a single value
# from functools import reduce
# ─────────────────────────────────────
from functools import reduce
numbers = [1, 2, 3, 4, 5]
# Sum
total = reduce(lambda acc, x: acc + x, numbers)
print(f"Sum: {total}") # 15
# Product
product = reduce(lambda acc, x: acc * x, numbers)
print(f"Product: {product}") # 120
# Maximum
maximum = reduce(lambda a, b: a if a > b else b, numbers)
print(f"Maximum: {maximum}") # 5
# String joining
words = ["Python", "is", "awesome"]
sentence = reduce(lambda s1, s2: s1 + " " + s2, words)
print(f"Sentence: {sentence}") # Python is awesome
# Real use: Total shopping cart value
cart = [
{"item": "Book", "price": 299, "qty": 2},
{"item": "Pen", "price": 15, "qty": 5},
{"item": "Bag", "price": 850, "qty": 1},
]
total_value = reduce(
lambda acc, item: acc + (item["price"] * item["qty"]),
cart,
0 # Initial value
)
print(f"\n🛒 Cart Total: ₹{total_value}")
| Sum | 15 |
| Product | 120 |
| Maximum | 5 |
| Sentence | Python is awesome |
| 🛒 Cart Total | ₹1721 |
7️⃣ Immediately Invoked Lambda (IIFE)
Example
# ─────────────────────────────────────
# Lambda turant call karna
# ─────────────────────────────────────
# Use once and forget
result = (lambda x, y: x ** 2 + y ** 2)(3, 4)
print(f"3² + 4² = {result}") # 25
# Quick calculation
area = (lambda r: 3.14159 * r * r)(7)
print(f"Area of circle: {area:.2f}") # 153.94
# Tax calculator
price = 1000
price_with_tax = (lambda p, tax: p + (p * tax / 100))(price, 18)
print(f"₹{price} + 18% GST = ₹{price_with_tax:.2f}")
Example
# OUTPUT:
3² + 4² = 25
Area of circle: 153.94
₹1000 + 18% GST = ₹1180.00
8️⃣ Lambda as Callback / Event Handler
Example
# ─────────────────────────────────────
# Lambda as callback function
# ─────────────────────────────────────
def process_data(data, transform_func, filter_func=None):
"""
Data process karta hai given transform aur filter functions se.
"""
# Transform
transformed = list(map(transform_func, data))
# Filter (optional)
if filter_func:
transformed = list(filter(filter_func, transformed))
return transformed
# Sales data (₹)
sales = [1500, 3200, 800, 5500, 2100, 4800, 950]
# Apply 15% bonus and filter sales > 2000
result = process_data(
sales,
transform_func=lambda x: x * 1.15, # 15% bonus
filter_func=lambda x: x > 2000 # Only high sales
)
print("High sales after bonus:")
for s in result:
print(f" ₹{s:,.2f}")
# Temperature data processing
temps = [18, 22, 35, 8, 28, 40, 15, 33]
extreme_temps = process_data(
temps,
transform_func=lambda t: (t * 9/5) + 32, # C to F
filter_func=lambda t: t > 90 # Above 90°F
)
print(f"\nExtreme temperatures (>90°F): {[f'{t:.1f}°F' for t in extreme_temps]}")
Example
# OUTPUT:
High sales after bonus:
₹3,680.00
₹6,325.00
₹2,415.00
₹5,520.00
Extreme temperatures (>90°F): ['95.0°F', '100.4°F', '91.4°F']
⚠️ Lambda ke Limitations
Example
# ─────────────────────────────────────
# Lambda limitations — when NOT to use
# ─────────────────────────────────────
# ❌ Multiple statements not allowed in lambda
# bad = lambda x: x = x + 1; return x # SyntaxError
# ❌ Assignment not allowed in lambda (except walrus :=)
# bad = lambda x: y = x * 2 # SyntaxError
# ❌ Exception handling not allowed in lambda
# bad = lambda x: try: return int(x) except: return 0 # SyntaxError
# ✅ Use regular def for these cases
def safe_int(x):
try:
return int(x)
except (ValueError, TypeError):
return 0
print(safe_int("42")) # 42
print(safe_int("abc")) # 0
# ─── Lambda vs Def — Decision Guide ───
print("""
┌─────────────────────────────────────────────────────┐
│ LAMBDA vs DEF — WHEN TO USE? │
├─────────────────────────────────────────────────────┤
│ USE LAMBDA when: │
│ ✅ Simple one-line expression │
│ ✅ map/filter/sorted ke saath key function │
│ ✅ Short-lived, one-time use │
│ ✅ Callback as argument │
│ │
│ USE DEF when: │
│ ✅ Multiple statements │
│ ✅ Loops, conditionals, try-except │
│ ✅ Function ko naam dena ho (reuse) │
│ ✅ Docstring likhna ho │
│ ✅ Complex logic │
└─────────────────────────────────────────────────────┘
""")
🏗️ Real-World: Data Processing Pipeline
Example
# ─────────────────────────────────────
# E-commerce order processing with lambdas
# ─────────────────────────────────────
orders = [
{"id": "ORD001", "customer": "Rahul", "amount": 1250, "status": "delivered", "category": "Electronics"},
{"id": "ORD002", "customer": "Priya", "amount": 850, "status": "pending", "category": "Books"},
{"id": "ORD003", "customer": "Amit", "amount": 3200, "status": "delivered", "category": "Electronics"},
{"id": "ORD004", "customer": "Sunita", "amount": 450, "status": "cancelled", "category": "Clothing"},
{"id": "ORD005", "customer": "Rohan", "amount": 5500, "status": "delivered", "category": "Electronics"},
{"id": "ORD006", "customer": "Meera", "amount": 280, "status": "delivered", "category": "Books"},
]
# 1. Sirf delivered orders
delivered = list(filter(lambda o: o["status"] == "delivered", orders))
# 2. Order amounts sort karo (descending)
sorted_orders = sorted(delivered, key=lambda o: o["amount"], reverse=True)
# 3. Har order pe loyalty points add karo (1 point per ₹10)
with_points = list(map(
lambda o: {**o, "loyalty_points": o["amount"] // 10},
sorted_orders
))
# 4. Total revenue
total_revenue = reduce(lambda acc, o: acc + o["amount"], delivered, 0)
# Display
print("🛒 DELIVERED ORDERS (by amount)")
print("=" * 60)
for o in with_points:
print(f" {o['id']} | {o['customer']:<8} | ₹{o['amount']:>5,} | {o['loyalty_points']} pts | {o['category']}")
print("=" * 60)
print(f" 💰 Total Revenue : ₹{total_revenue:,}")
print(f" 📦 Total Delivered: {len(delivered)}")
print(f" ⭐ Avg Order Value : ₹{total_revenue//len(delivered):,}")
| 💰 Total Revenue | ₹10,230 |
| 📦 Total Delivered | 4 |
| ⭐ Avg Order Value | ₹2,557 |
❓ Interview Questions
Q1: Can you name a lambda function?
python example
# Technically yes, but not recommended
square = lambda x: x**2 # PEP8: use def instead
# Better:
def square(x): return x**2Q2: Can lambda have default arguments?
python example
add = lambda x, y=10: x + y
print(add(5)) # 15
print(add(5, 3)) # 8Q3: Lambda function __name__ kya return karta hai?
python example
f = lambda x: x
print(f.__name__) # '<lambda>'Q4: map() vs list comprehension — kaunsa better hai?
Example
nums = [1, 2, 3, 4, 5]
# map + lambda
result1 = list(map(lambda x: x**2, nums))
# List comprehension (more Pythonic)
result2 = [x**2 for x in nums]
# Both give the same result, LC is more readable
📋 Summary
┌─────────────────────────────────────────────────────┐
│ LAMBDA FUNCTIONS — QUICK RECAP │
├─────────────────────────────────────────────────────┤
│ ✅ lambda keyword se anonymous function banta hai │
│ ✅ Single expression, implicit return │
│ ✅ map(), filter(), sorted() ke saath use karo │
│ ✅ reduce() se aggregation kar sakte hain │
│ ✅ Callback/key function ke roop mein use karo │
│ ✅ Complex logic ke liye def use karo │
│ ✅ Default args, *args bhi support karta hai │
└─────────────────────────────────────────────────────┘
🚀 Next: To learn Recursive Functions, read recursive-functions.mdx!⚠️ Common Mistakes
❌ Mistake 1: Writing multiple statements in lambda
python example
# ❌ WRONG — Lambda only supports a single expression
# bad = lambda x: x = x + 1; print(x) # SyntaxError!
# ✅ RIGHT — Use regular def for multiple statements
def increment_and_print(x):
x = x + 1
print(x)
return x
increment_and_print(5)Example
# OUTPUT:
6
❌ Mistake 2: Assigning lambda to a variable (PEP8 violation)
python example
# ❌ WRONG — PEP8 kehta hai lambda ko naam mat do
multiply = lambda x, y: x * y
# ✅ RIGHT — If you need a name, use def
def multiply(x, y):
return x * y
print(multiply(3, 4))Example
# OUTPUT:
12
❌ Mistake 3: Writing complex nested ternary in lambda
python example
# ❌ WRONG — Hard to read
classify = lambda x: "Positive" if x > 0 else ("Zero" if x == 0 else ("Slightly Negative" if x > -5 else "Very Negative"))
# ✅ RIGHT — Use def for readability
def classify(x):
if x > 0: return "Positive"
elif x == 0: return "Zero"
elif x > -5: return "Slightly Negative"
else: return "Very Negative"
print(classify(-3))
print(classify(10))Example
# OUTPUT:
Slightly Negative
Positive
❌ Mistake 4: Lambda ke andar loop variable capture issue
Example
# ❌ WRONG — Late binding problem!
funcs = [lambda: i for i in range(5)]
print([f() for f in funcs]) # [4, 4, 4, 4, 4] 😱 Sab 4!
# ✅ RIGHT — Fix with default argument
funcs_fixed = [lambda i=i: i for i in range(5)]
print([f() for f in funcs_fixed]) # [0, 1, 2, 3, 4] ✅
Example
# OUTPUT:
[4, 4, 4, 4, 4]
[0, 1, 2, 3, 4]
❌ Mistake 5: Modifying in filter() instead of filtering
Example
# ❌ WRONG — filter() only checks True/False, does not modify
nums = [1, 2, 3, 4, 5]
# This is wrong thinking: filter will double values
result = list(filter(lambda x: x * 2, nums))
print(f"Filter result: {result}") # Sab aa gaye! (kyunki x*2 truthy hai)
# ✅ RIGHT — Use map() for modification
result = list(map(lambda x: x * 2, nums))
print(f"Map result: {result}")
Example
# OUTPUT:
Filter result: [1, 2, 3, 4, 5]
Map result: [2, 4, 6, 8, 10]
❌ Mistake 6: Lambda mein print() daal dena
Example
# ❌ WRONG — print() returns None, lambda's return becomes None
nums = [1, 2, 3]
result = list(map(lambda x: print(x * 2), nums))
print(f"Result list: {result}") # [None, None, None] 😢
# ✅ RIGHT — Return the expression, print separately
result = list(map(lambda x: x * 2, nums))
print(f"Result list: {result}")
Example
# OUTPUT:
2
4
6
Result list: [None, None, None]
Result list: [2, 4, 6]
❌ Mistake 7: reduce() mein initial value bhoolna
python example
from functools import reduce
# ❌ WRONG — Empty list pe reduce without initial = TypeError!
try:
result = reduce(lambda a, b: a + b, [])
except TypeError as e:
print(f"Error: {e}")
# ✅ RIGHT — Provide an initial value for safety
result = reduce(lambda a, b: a + b, [], 0)
print(f"Safe result: {result}")Example
# OUTPUT:
Error: reduce() of empty iterable with no initial value
Safe result: 0
✅ Key Takeaways
- 🔹 Lambda = Anonymous Function — A small function without a name, written in a single expression
- 🔹 Syntax:
lambda arguments: expression— No need to writereturn, it's implicit - 🔹 With map() — Use to transform each element (celsius to fahrenheit, price after discount)
- 🔹 With filter() — Use to filter elements based on a condition (even numbers, passed students)
- 🔹 With sorted() — Use
key=lambdato define custom sorting logic (salary, rating, price) - 🔹 With reduce() — To combine an entire list into a single value (sum, product, max)
- 🔹 Remember limitations — Lambda cannot have multiple statements, loops, try-except, or assignments
- 🔹 PEP8 Rule — Don't assign lambda to a variable; if you need a name, use
def - 🔹 Readability > Cleverness — If lambda looks confusing, write a regular function
- 🔹 IIFE Pattern —
(lambda x: x**2)(5)lets you immediately invoke without naming
❓ FAQ
Q1: What is the difference between a lambda function and a regular function?
Answer: Lambda is an anonymous (nameless) function written in just one expression. In a regular def function, you can have multiple statements, loops, exception handling, etc. Lambda is used when you have a small task to do in one place — like providing a key function in sorted(). Use a regular function when the logic is complex or the function needs to be reused.
Q2: Can you give multiple arguments to a lambda function?
Answer: Yes, absolutely! You can give unlimited arguments in lambda — separated by commas. Example: lambda a, b, c: a + b + c. Default arguments are also supported: lambda x, y=10: x + y. And you can use *args too: lambda *args: sum(args).
Q3: When should you use a lambda function and when not?
Answer: Use lambda when: (1) It's a simple one-liner expression, (2) You need a quick function with map/filter/sorted, (3) The function will only be used once. Don't use lambda when: (1) Logic is complex (2+ lines), (2) Error handling is needed, (3) The function needs to be reusable, (4) A docstring is needed.
Q4: Should you use map() or list comprehension?
Answer: Both do the same thing, but list comprehension is considered more Pythonic. [x2 for x in nums] is easier to read vs list(map(lambda x: x2, nums)). But when a function is already defined (like str.upper), map(str.upper, words) looks cleaner. The performance difference is negligible.
Q5: How to write if-else inside lambda?
Answer: Use the ternary operator in lambda: lambda x: "Even" if x % 2 == 0 else "Odd". But avoid nested ternary — lambda x: "A" if x>90 else ("B" if x>80 else "C") is not readable. In such situations, def is better.
Q6: Kya lambda recursion support karta hai?
Answer: Technically yes, but it's very tricky and impractical. Lambda is anonymous so calling itself is difficult. If you need recursion, always use a regular def function.
Q7: reduce() function Python 3 mein directly available hai?
Answer: No! In Python 3, reduce() is not built-in. To use it, you have to write from functools import reduce. Python moved it out of built-ins.
Q8: How to debug a lambda function?
Answer: Debugging lambda is difficult because: (1) Its name shows as <lambda> in tracebacks, (2) Setting breakpoints is tricky, (3) You can't easily add print statements. Tip: First convert complex lambda to a regular function, debug it, then if needed write it back as lambda.
🎯 Interview Questions
Q1: What is a lambda function? Explain its syntax.
Answer: Lambda is an anonymous (nameless) function created with the lambda keyword. Syntax: lambda arguments: expression. It evaluates only one expression and implicitly returns it. Example: lambda x, y: x + y returns the sum of two numbers. It's primarily used with higher-order functions like map(), filter(), sorted().
Q2: Lambda function ki limitations kya hain?
Answer: Lambda ki limitations:
- ❌ You can write only one expression — no multiple statements
- ❌ Assignment is not possible (
y = x * 2is invalid) - ❌ try-except cannot be written — error handling is impossible
- ❌ Loops (for/while) cannot be included
- ❌ Docstring cannot be added
- ❌ Debugging is difficult —
<lambda>appears in tracebacks - ❌ Complex nested logic unreadable ho jaata hai
Q3: What is the difference between map(), filter(), and reduce()?
Answer:
map(func, iterable)— Applies the function to each element and returns a new iterable. Used for transformation. Output length = input length.filter(func, iterable)— Keeps only elements where the function returnsTrue. Used for filtering. Output length ≤ input length.reduce(func, iterable)— Reduces the entire list to a single value by accumulating. Used for aggregation (sum, product, finding max/min).
Q4: How does closure work in lambda? Explain the loop variable trap.
Answer: Lambda accesses variables from the enclosing scope through closure. Problem: When creating lambdas in a loop, all lambdas share the same variable reference (late binding). Fix: Use a default argument.
Example
# Problem: [lambda: i for i in range(3)] → sab 2 return karenge
# Fix: [lambda i=i: i for i in range(3)] → 0, 1, 2 correctly return karenge
This happens because lambda looks at the value of i at execution time, not definition time. A default argument captures the value at definition time.
Q5: What is the role of key=lambda in sorted()?
Answer: The key parameter of sorted() accepts a function that generates a comparison value for each element. Lambda is perfect here as you don't need a named function for a one-liner comparison logic.
Example
students = [{"name": "A", "marks": 80}, {"name": "B", "marks": 90}]
sorted(students, key=lambda s: s["marks"]) # marks ke basis pe sort
The key function is called on each element, comparison happens based on the return value, and original elements remain untouched. Multiple criteria can be handled by returning tuples.
Q6: Lambda vs List Comprehension — performance comparison?
Answer: List comprehension is generally slightly faster than map() + lambda because:
- Lambda has function call overhead on every iteration
- List comprehension Python internally optimize karta hai
- Lekin difference negligible hai (microseconds level)
Rule of thumb: Readability first! Use list comprehension for simple transformations. When you need to pass an existing function (like str.upper), map() is cleaner.
Q7: What is a higher-order function? How does lambda relate to it?
Answer: Higher-order function wo function hai jo:
- Accepts a function as an argument, or
- Function return kare
map(), filter(), sorted(), reduce() are all higher-order functions. Lambda is their natural partner — for quickly providing throwaway functions.
Q8: How does IIFE (Immediately Invoked Function Expression) work in Python?
Answer: In the IIFE pattern, lambda is defined and called in a single line:
python example
result = (lambda x, y: x**2 + y**2)(3, 4) # 25Use cases: Quick one-time calculations, complex default values, and when you don't want to create a temporary variable. Wrapping lambda in parentheses and calling it immediately.
Q9: Can you use *args and **kwargs in lambda?
Answer: Yes! Lambda supports both *args and **kwargs:
python example
sum_all = lambda *args: sum(args)
print(sum_all(1, 2, 3, 4)) # 10
make_dict = lambda **kwargs: kwargs
print(make_dict(name="Rahul", age=25)) # {'name': 'Rahul', 'age': 25}But you can't do complex unpacking or multiple operations in lambda, so even with *args/**kwargs, keep the expression simple.
Q10: What is the most common use case of lambda in real-world projects?
Answer: In the real world, lambda is most commonly used for:
- Sorting —
sorted(employees, key=lambda e: e.salary) - DataFrame operations —
df.apply(lambda row: row.price * row.qty, axis=1) - Event handlers — GUI frameworks mein button callbacks
- API callbacks —
requests.get(url, hooks={'response': lambda r: print(r.status_code)}) - Dictionary sorting —
sorted(d.items(), key=lambda x: x[1])
In Pandas/Data Science, lambda is very frequently used with .apply(), .map(), .filter().
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Lambda Functions in Python.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, functions, lambda, lambda functions in python
Related Python Master Course Topics
Continue learning this concept
FunctionsDecorators in PythonDetailed guide to Python decorators — function decorators, class decorators, stacking, functools.wraps, and real-world use cases. Learn with examples and best practices.FunctionsFunction Arguments in PythonComplete guide to Python function arguments — positional, keyword, default, *args, **kwargs and their real-world use cases. Understand argument types with best practices.FunctionsFunctions Basics in PythonPython mein functions ki complete guide — definition, calling, types, aur best practices. Samjho functions ka syntax, purpose, aur real-world usage Hindi explanations ke saath.FunctionsGenerators in PythonPython generators ki detailed guide — yield keyword, generator functions, generator expressions, send/throw/close, aur real-world use cases jaise infinite sequences, data pipelines, aur memory-efficient file processing. Hindi mein.FunctionsRecursive Functions in PythonPython mein recursion ki complete guide — base case, recursive case, call stack, fibonacci, factorial, binary search aur tree traversal ke saath Hindi explanations.FunctionsReturn Statement in PythonPython mein return statement ki poori guide — single/multiple return values, early return, None return, aur real-world patterns. Hindi mein samjho return ke saare use cases.