Functions & Lambda — Complete Deep Dive 🔧

Functions Python ka backbone hain — code reusability, modularity, aur clean architecture ki foundation. Basic def se lekar *args, **kwargs, Lambda, Decorators, aur Type Hints tak — complete deep dive. Data Insights par.

📑 Is Chapter Mein Kya Sikhenge:

• 🟢 Basic: Functions Intro, Parameters vs Arguments, Default Parameters
• 🟡 Medium: Keyword Arguments, *args, **kwargs
• 🔴 Advanced (Part 8B): Return Multiple Values, Scope (LEGB), Lambda, map/filter/reduce, Decorators, Type Hints

📘 Definition: A Function is a reusable block of code that performs a specific task. It is defined using the def keyword, followed by the function name, parameters in parentheses, and a colon. The function body is indented. Functions may or may not return a value. Functions promote code reusability, modularity, and readability — write once, use many times.

🎯 Samjho Hinglish Mein: Function ek recipe hai. Ek baar likh diya (define), phir baar baar use karo (call). "Cha banao" ek function hai — ek baar recipe likhi, jab bhi cha chahiye, "cha_banao()" call kar do. Bina function ke same code baar baar copy-paste karna padta hai — DRY principle violate hoti hai (Don't Repeat Yourself). Functions se code clean, maintainable, aur reusable banta hai.

📋 Function Syntax & Rules:

Syntax: def function_name(parameters): """Docstring (optional)""" # Function body return value # Optional
Rules:
• Function name should be lowercase, use underscores (snake_case)
• Cannot start with number
• Cannot use Python keywords (if, for, def, class, etc.)
• Body must be indented (4 spaces recommended)
• return statement is OPTIONAL — default return is None
• Function name should describe what it does

💻 Examples:

# Example 1: Simple function without parameters def greet(): print("Hello, welcome to Python!")
# Call the function
greet() # Hello, welcome to Python!
greet() # Hello, welcome to Python! (call again — reusable!)
greet() # Hello, welcome to Python!

# Example 2: Function with parameters & return def add_numbers(a, b): result = a + b return result # Call and capture returned value total = add_numbers(10, 20) print(total) # 30 # Use return value directly print(add_numbers(5, 15)) # 20 print(add_numbers(100, 200)) # 300

# Example 3: Practical — Calculate discount def calculate_discount(price, discount_percent): """Calculate final price after discount""" discount_amount = price * discount_percent / 100 final_price = price - discount_amount return final_price # Use for multiple products print(calculate_discount(1000, 10)) # 900.0 print(calculate_discount(5000, 20)) # 4000.0 print(calculate_discount(2500, 15)) # 2125.0 # Same function, different inputs — reusability!

💬 Interview Q&A:

📘 Definition: Parameters are the variables listed in the function definition (parentheses after function name). Arguments are the actual VALUES passed to the function when calling it. Parameters are placeholders, arguments are real data. This distinction is important in interviews and understanding Python.

🎯 Samjho Hinglish Mein: Function likhte waqt jo variables likhte ho — woh Parameters hain (placeholders). Function call karte waqt jo values pass karte ho — woh Arguments hain. Example: def add(a, b) mein a, b PARAMETERS hain. add(10, 20) mein 10, 20 ARGUMENTS hain. Parameters = khaali dabbe, Arguments = un dabbon mein daali gayi cheezein.

📋 Comparison:

💻 Examples:

# Example 1: Positional Arguments (order matters!) def introduce(name, age, city): # name, age, city → Parameters print(f"Hi, I'm {name}, {age} years old, from {city}")
# Arguments passed in order:
introduce("Jatin", 25, "Gurugram")
# Hi, I'm Jatin, 25 years old, from Gurugram

# ⚠️ ORDER MATTERS in positional args!
introduce(25, "Jatin", "Gurugram")
# Hi, I'm 25, Jatin years old, from Gurugram (wrong!)

# Example 2: Wrong number of arguments — Error! def add(a, b):
     return a + b # Correct call print(add(10, 20)) # 30 ✅ # Too few arguments # add(10) → TypeError: missing 1 required positional argument: 'b' # Too many arguments # add(10, 20, 30) → TypeError: takes 2 positional arguments but 3 were given

# Example 3: Passing different data types def process_data(name, scores, is_active):
     print(f"Name: {name}") print(f"Total Scores: {sum(scores)}") print(f"Active: {is_active}") # Pass string, list, boolean process_data("Jatin", [85, 90, 78], True) # Name: Jatin # Total Scores: 253 # Active: True

📘 Definition: Default Parameters allow you to specify a default value for a parameter in the function definition. If the caller doesn't provide that argument, the default value is used. Default parameters make functions more flexible and reduce the need to always pass all arguments. Important Rule: Default parameters MUST come AFTER non-default parameters.

🎯 Samjho Hinglish Mein: Default parameter = "agar tumne kuch nahi diya toh yeh default value use hogi." Restaurant mein bolo "cha" — agar tum "adrak wali" ya "elaichi wali" specify nahi karte toh chef default (normal cha) bana dega. Function mein bhi same — def greet(name, greeting="Hello") — agar greeting nahi diya toh "Hello" use hoga. Flexibility milti hai — kabhi override karo, kabhi default rakho.

💻 Examples:

# Example 1: Basic default parameter def greet(name, greeting="Hello"): return f"{greeting}, {name}!"
# Without providing greeting — uses default
print(greet("Jatin"))
# Hello, Jatin!

# Provide custom greeting — overrides default
print(greet("Priya", "Namaste"))
# Namaste, Priya!

print(greet("Rahul", "Hi"))
# Hi, Rahul!

# Example 2: Multiple defaults def create_user(name, age=18, role="User", is_active=True):
     return { "name": name, "age": age, "role": role, "active": is_active } # Only name required — rest defaults print(create_user("Jatin")) # {'name': 'Jatin', 'age': 18, 'role': 'User', 'active': True} # Override some defaults print(create_user("Admin", role="Admin")) # {'name': 'Admin', 'age': 18, 'role': 'Admin', 'active': True} # Override all print(create_user("Test", 25, "Manager", False)) # {'name': 'Test', 'age': 25, 'role': 'Manager', 'active': False}

# Example 3: ⚠️ IMPORTANT RULE — order matters! # ✅ CORRECT: defaults AFTER non-defaults def calc(a, b, operation="add"):
     if operation == "add":
     return a + b elif operation == "multiply":
     return a * b print(calc(10, 20)) # 30 (default add) print(calc(10, 20, "multiply")) # 200 # ❌ WRONG: default BEFORE non-default # def bad_func(a=10, b): → SyntaxError! # Non-default argument follows default argument

💬 Interview Q&A:

📘 Definition: Keyword Arguments (kwargs) allow you to pass arguments to a function using the parameter name explicitly — like function(name="Jatin", age=25). This way, the ORDER doesn't matter — Python matches argument to parameter by name, not position. Keyword arguments make code more readable and less error-prone.

🎯 Samjho Hinglish Mein: Positional arguments mein order important hai — add(10, 20) mein pehla 10 a, doosra 20 b. Keyword arguments mein tum naam batate ho — add(a=10, b=20) ya add(b=20, a=10) — dono same result! Order matter nahi karta. Yeh readability improve karta hai — function call dekhne se hi pata chal jaata hai kaunsa value kaunse parameter ke liye hai.

💻 Examples:

# Example 1: Keyword args — order doesn't matter! def introduce(name, age, city): return f"{name}, {age}, from {city}"
# Positional (order matters)
print(introduce("Jatin", 25, "Gurugram"))
# Jatin, 25, from Gurugram

# Keyword args — order doesn't matter!
print(introduce(city="Delhi", name="Priya", age=28))
# Priya, 28, from Delhi

print(introduce(age=30, name="Rahul", city="Mumbai"))
# Rahul, 30, from Mumbai

# Example 2: Mix positional + keyword args def book_ticket(name, source, destination, class_type="Economy"):
     return f"{name} — {source} to {destination} ({class_type})" # Positional first, then keyword print(book_ticket("Jatin", "Delhi", "Mumbai", class_type="Business")) # Jatin — Delhi to Mumbai (Business) # Only override specific default print(book_ticket("Priya", "Chennai", "Bangalore")) # Priya — Chennai to Bangalore (Economy) # ⚠️ RULE: Positional args MUST come before keyword args # book_ticket(name="Jatin", "Delhi", "Mumbai") → SyntaxError!

# Example 3: Readability comparison — REAL WORLD def send_email(to, subject, body, cc=None, bcc=None, priority="normal"): return f"Email sent to {to} with priority {priority}" # ❌ Bad — hard to understand what each argument does send_email("jatin@gmail.com", "Meeting", "Tomorrow 5pm", None, None, "high") # ✅ Good — self-documenting with keyword args send_email( to="jatin@gmail.com", subject="Meeting", body="Tomorrow 5pm", priority="high" ) # Much clearer! Skip cc and bcc — defaults used

💬 Interview Q&A:

📘 Definition: *args allows a function to accept a VARIABLE number of positional arguments. The asterisk * before the parameter name tells Python to pack all extra positional arguments into a TUPLE. The name "args" is convention — you can name it anything (*items, *numbers), but stick to *args for readability.

🎯 Samjho Hinglish Mein: Kabhi tumhe pata nahi hota ki function ko kitne arguments chahiye. Jaise sum() function — 2 numbers ho ya 100, sab work karta hai. *args se yeh possible hai — tum jitne bhi arguments pass karo, Python un sab ko ek TUPLE mein pack kar deta hai. def add(*nums) mein add(1,2,3,4,5) — nums = (1,2,3,4,5). Ab tuple par iterate karke sum kar sakte ho.

💻 Examples:

# Example 1: Basic *args — accept any number of arguments def add_all(*numbers): print(f"Received: {numbers}") print(f"Type: {type(numbers)}") return sum(numbers)
# Pass any number of args
print(add_all(1, 2, 3))
# Received: (1, 2, 3)
# Type: 
# 6

print(add_all(10, 20, 30, 40, 50))
# Received: (10, 20, 30, 40, 50)
# 150

print(add_all()) # Empty tuple ()
# 0

# Example 2: *args with regular parameters def shopping_bill(customer_name, *items):
     print(f"Customer: {customer_name}") print(f"Items purchased:") for i, item in enumerate(items, 1):
     print(f" {i}. {item}") print(f"Total items: {len(items)}") shopping_bill("Jatin", "Milk", "Bread", "Eggs", "Butter") # Customer: Jatin # Items purchased: # 1. Milk # 2. Bread # 3. Eggs # 4. Butter # Total items: 4

# Example 3: Unpacking a list into *args def max_of_all(*numbers):
     if not numbers:
     return None return max(numbers) # Normal call print(max_of_all(10, 45, 23, 78, 12)) # 78 # Unpack a list using * — magic! scores = [85, 92, 78, 96, 88] print(max_of_all(*scores)) # 96 # *scores unpacks list to individual args: 85, 92, 78, 96, 88 # Without unpacking — treats list as single argument (wrong!) # print(max_of_all(scores)) → TypeError!

💬 Interview Q&A:

📘 Definition: **kwargs allows a function to accept a VARIABLE number of KEYWORD arguments. The double asterisk ** before the parameter name tells Python to pack all extra keyword arguments into a DICTIONARY (key = argument name, value = argument value). Convention: use **kwargs — but any name works.

🎯 Samjho Hinglish Mein: *args extra positional arguments ko TUPLE mein pack karta hai. **kwargs extra KEYWORD arguments ko DICTIONARY mein pack karta hai. def func(**kwargs) mein func(name="Jatin", age=25) — kwargs = {"name": "Jatin", "age": 25}. Ab dictionary par iterate karke process kar sakte ho. Yeh flexible API design ke liye bahut useful hai — Django, Flask, requests library sab **kwargs use karte hain.

💻 Examples:

# Example 1: Basic **kwargs def print_info(**details): print(f"Received: {details}") print(f"Type: {type(details)}") for key, value in details.items(): print(f"{key}: {value}")
print_info(name="Jatin", age=25, city="Gurugram")
# Received: {'name': 'Jatin', 'age': 25, 'city': 'Gurugram'}
# Type: 
# name: Jatin
# age: 25
# city: Gurugram

# Example 2: Combining *args and **kwargs def flexible_func(required_arg, *args, **kwargs):
     print(f"Required: {required_arg}") print(f"Positional (args): {args}") print(f"Keyword (kwargs): {kwargs}") flexible_func( "Hello", # required_arg 1, 2, 3, # *args → (1, 2, 3) name="Jatin", # **kwargs → {'name': 'Jatin', ...} age=25 ) # Required: Hello # Positional (args): (1, 2, 3) # Keyword (kwargs): {'name': 'Jatin', 'age': 25}

# Example 3: Real-world — API config function def create_user_profile(name, **profile_data): profile = {"name": name} profile.update(profile_data) # Merge kwargs into profile return profile # Different callers pass different data user1 = create_user_profile( "Jatin", age=25, city="Gurugram", email="jatin@gmail.com" ) print(user1) # {'name': 'Jatin', 'age': 25, 'city': 'Gurugram', 'email': 'jatin@gmail.com'} user2 = create_user_profile( "Priya", phone="9876543210", profession="Data Analyst" ) print(user2) # {'name': 'Priya', 'phone': '9876543210', 'profession': 'Data Analyst'} # Unpack dict into **kwargs using ** data = {"age": 30, "city": "Delhi", "role": "Manager"} user3 = create_user_profile("Rahul", **data) print(user3) # {'name': 'Rahul', 'age': 30, 'city': 'Delhi', 'role': 'Manager'}

📋 Parameter Order Rule:

CORRECT ORDER in function definition: def func(regular, *args, default_arg=value, **kwargs): ↑ ↑ ↑ ↑ Required Variable pos. Default Variable keyword
Example:
def process(name, *tags, active=True, **metadata):
...

Call:
process("Jatin", "python", "sql", active=False, city="Delhi", age=25)
↑ ↑ ↑ ↑ ↑ ↑
name tags→(...) default active=False metadata→{...}

💬 Interview Q&A:

📘 Definition: Python allows functions to return multiple values by separating them with commas in the return statement. Internally, Python packs these values into a TUPLE and returns it. The caller can either receive the entire tuple or unpack the values into separate variables. This is a Python-specific feature — most languages require returning a struct, class, or array.

🎯 Samjho Hinglish Mein: Kabhi tumhe ek function se ek se zyada values chahiye hoti hain. Jaise divide() function karo — quotient bhi chahiye aur remainder bhi. Python mein return quotient, remainder likh do — dono values ek saath return ho jaayengi. Receive karne ke 2 tarike hain: (1) Ek variable mein — tuple milega. (2) Do variables mein — automatic unpacking. Java/C++ mein yeh possible nahi — Python special hai!

💻 Examples:

# Example 1: Return multiple values (as tuple) def divide(a, b): quotient = a // b remainder = a % b return quotient, remainder # Comma separated → tuple
# Method 1: Receive as tuple
result = divide(17, 5)
print(result) # (3, 2)
print(type(result)) # 
print(result[0]) # 3 (quotient)

# Method 2: Unpack into variables (Pythonic!)
q, r = divide(17, 5)
print(f"Quotient: {q}, Remainder: {r}")
# Quotient: 3, Remainder: 2

# Example 2: Statistics function — multiple metrics def calculate_stats(numbers): total = sum(numbers) count = len(numbers) average = total / count max_val = max(numbers) min_val = min(numbers) return total, count, average, max_val, min_val # Unpack into 5 variables at once scores = [85, 92, 78, 96, 88] total, count, avg, high, low = calculate_stats(scores) print(f"Total: {total}") # Total: 439 print(f"Count: {count}") # Count: 5 print(f"Average: {avg}") # Average: 87.8 print(f"Highest: {high}") # Highest: 96 print(f"Lowest: {low}") # Lowest: 78

# Example 3: Return dict for named values (better for many returns) def analyze_employee(salary, years): bonus = salary * 0.10 tax = salary * 0.20 net = salary - tax + bonus return { "gross_salary": salary, "bonus": bonus, "tax": tax, "net_salary": net, "experience": years } # Access by name — more readable than tuple index result = analyze_employee(50000, 3) print(f"Net Salary: ₹{result['net_salary']}") print(f"Bonus: ₹{result['bonus']}") # Net Salary: ₹45000.0 # Bonus: ₹5000.0

💬 Interview Q&A:

📘 Definition: Scope defines WHERE a variable is accessible in the code. Python follows the LEGB Rule: Local (inside current function) → Enclosing (outer function if nested) → Global (module level) → Built-in (Python built-ins like print, len). Python searches for a variable in this exact order. To modify a global variable inside a function, use global keyword. For enclosing scope, use nonlocal.

🎯 Samjho Hinglish Mein: Scope = "kahan variable exist karta hai." LEGB rule ka matlab — Python variable dhundhne mein 4 places check karta hai in order: (1) Local — abhi wale function ke andar. (2) Enclosing — bahar wale function mein (agar nested). (3) Global — module level (function ke bahar). (4) Built-in — Python ka default (print, len, etc.). Local variable ko function ke bahar access nahi kar sakte. Global ko function ke andar READ kar sakte ho, MODIFY karne ke liye global keyword chahiye.

📋 LEGB Rule Visualized:

Python variable lookup order:
┌─────────────────────────────────────────┐
│ 4. BUILT-IN Scope │ ← print(), len(), sum()
│ ┌──────────────────────────────────┐ │ (Python's built-ins)
│ │ 3. GLOBAL Scope │ │
│ │ ┌────────────────────────────┐ │ │ ← Module-level variables
│ │ │ 2. ENCLOSING Scope │ │ │ (outside all functions)
│ │ │ ┌──────────────────────┐ │ │ │
│ │ │ │ 1. LOCAL Scope │ │ │ │ ← Outer function (nested)
│ │ │ │ x = 10 ← Found! │ │ │ │ ← Inside current function
│ │ │ └──────────────────────┘ │ │ │
│ │ └────────────────────────────┘ │ │
│ └──────────────────────────────────┘ │
└─────────────────────────────────────────┘

Python STOPS as soon as variable is found in innermost scope.

💻 Examples:

# Example 1: Local vs Global message = "I am GLOBAL" # Global scope
def show():
message = "I am LOCAL" # Local scope (different!)
print(message)

show() # I am LOCAL (uses local)
print(message) # I am GLOBAL (unchanged!)

# Local variable dies when function ends
# print(message inside show()) — Not accessible outside!

# Example 2: global keyword — modify global variable counter = 0 # Global def increment_wrong(): counter = counter + 1 # ❌ Error! (trying to modify global) def increment_right(): global counter # ✅ Declare global first counter = counter + 1 # increment_wrong() → UnboundLocalError increment_right() increment_right() increment_right() print(counter) # 3 (global counter modified!)

# Example 3: LEGB in action — nested functions x = "Global X" # Global def outer(): x = "Enclosing X" # Enclosing def inner(): x = "Local X" # Local (found first!) print(f"Inner: {x}") inner() print(f"Outer: {x}") # Uses enclosing X outer() print(f"Module: {x}") # Uses global X # Output: # Inner: Local X # Outer: Enclosing X # Module: Global X # nonlocal — modify enclosing scope def counter_factory(): count = 0 # Enclosing def increment(): nonlocal count # Modify enclosing (not global!) count += 1 return count return increment my_counter = counter_factory() print(my_counter()) # 1 print(my_counter()) # 2 print(my_counter()) # 3

💬 Interview Q&A:

📘 Definition: A Lambda function is a small, anonymous (nameless) function defined using the lambda keyword. Syntax: lambda arguments: expression. Lambda functions are limited to a SINGLE expression — no statements, no multiple lines. They are used for short, one-time operations, especially with map(), filter(), sorted(), and Pandas operations. Also called "lambda expressions" or "arrow functions" in other languages.

🎯 Samjho Hinglish Mein: Lambda = mini function without a name. Jab tumhe bahut chota function chahiye — sirf ek line ka — aur naam dena bhi zaroori nahi (one-time use), tab lambda use karo. lambda x: x * 2 = ek function jo x le kar 2x return karta hai. Bina def, bina return likhe. Pandas mein df.apply(lambda x: x*2) bahut common hai. Regular function likhne se bachne ka shortcut hai lambda.

📋 Lambda vs Regular Function:

💻 Examples:

# Example 1: Basic Lambda
# Regular function
def square(x):
return x ** 2

# Lambda equivalent (one line!)
square_lambda = lambda x: x ** 2

print(square(5)) # 25
print(square_lambda(5)) # 25 (same result!)

# Lambda with multiple arguments
add = lambda a, b: a + b
multiply = lambda x, y, z: x * y * z

print(add(10, 20)) # 30
print(multiply(2, 3, 4)) # 24

# Example 2: Lambda with sorted() — custom sorting students = [ {"name": "Jatin", "score": 85}, {"name": "Priya", "score": 92}, {"name": "Rahul", "score": 78} ] # Sort by score (descending) using lambda sorted_students = sorted(students, key=lambda s: s["score"], reverse=True) for s in sorted_students:
     print(s) # {'name': 'Priya', 'score': 92} # {'name': 'Jatin', 'score': 85} # {'name': 'Rahul', 'score': 78} # Sort by name length names = ["Jatin", "Priya", "Rahul Kumar", "Ne"] print(sorted(names, key=lambda x: len(x))) # ['Ne', 'Jatin', 'Priya', 'Rahul Kumar']

# Example 3: Lambda with conditional (ternary) # Lambda with if-else grade = lambda score: "Pass" if score >= 40 else "Fail" print(grade(75)) # Pass print(grade(35)) # Fail # Multi-condition lambda category = lambda age: ( "Child" if age < 13 else "Teen" if age < 20 else "Adult" if age < 60 else "Senior" ) print(category(10)) # Child print(category(17)) # Teen print(category(45)) # Adult print(category(65)) # Senior

💬 Interview Q&A:

📘 Definition: These are functional programming tools that operate on iterables (lists, tuples). map(func, iterable) applies a function to EACH item — returns a new iterable. filter(func, iterable) keeps only items where function returns True. reduce(func, iterable) (from functools) reduces the iterable to a SINGLE value by applying function cumulatively. All three work beautifully with Lambda functions.

🎯 Samjho Hinglish Mein: Teen functional tools — sab list par kaam karte hain, tarike alag: (1) map() — har item par function apply karo (transform). "Har number ko square karo." (2) filter() — sirf woh items rakho jo condition satisfy karein. "Sirf positive numbers rakho." (3) reduce() — sab items ko combine karke ek value banao. "Saare numbers ka product nikalo." Lambda ke saath yeh super powerful hain — ek line mein complex operations ho jaate hain.

💻 Examples:

# Example 1: map() — Transform each item numbers = [1, 2, 3, 4, 5]
# Square each number
squared = list(map(lambda x: x ** 2, numbers))
print(squared)
# [1, 4, 9, 16, 25]

# Convert temperatures Celsius → Fahrenheit
celsius = [0, 25, 30, 40, 100]
fahrenheit = list(map(lambda c: (c * 9/5) + 32, celsius))
print(fahrenheit)
# [32.0, 77.0, 86.0, 104.0, 212.0]

# Convert names to uppercase
names = ["jatin", "priya", "rahul"]
upper_names = list(map(lambda n: n.upper(), names))
print(upper_names)
# ['JATIN', 'PRIYA', 'RAHUL']

map() with multiple iterables — element-wise operation
list1 = [1, 2, 3]
list2 = [10, 20, 30]
sums = list(map(lambda a, b: a + b, list1, list2))
print(sums) # [11, 22, 33]

# Example 2: filter() — Keep only matching items numbers = [1, -2, 3, -4, 5, 6, -7, 8] # Only positive numbers positives = list(filter(lambda x: x > 0, numbers)) print(positives) # [1, 3, 5, 6, 8] # Only even numbers evens = list(filter(lambda x: x % 2 == 0, numbers)) print(evens) # [-2, -4, 6, 8] # Real world — filter passing students students = [ {"name": "Jatin", "score": 85}, {"name": "Priya", "score": 32}, {"name": "Rahul", "score": 78}, {"name": "Neha", "score": 45} ] passed = list(filter(lambda s: s["score"] >= 40, students)) for student in passed:
     print(student) # {'name': 'Jatin', 'score': 85} # {'name': 'Rahul', 'score': 78} # {'name': 'Neha', 'score': 45}

# Example 3: reduce() — Reduce to single value from functools import reduce numbers = [1, 2, 3, 4, 5] # Sum all numbers total = reduce(lambda a, b: a + b, numbers) print(total) # 15 (same as sum()) # Product of all numbers (factorial) product = reduce(lambda a, b: a * b, numbers) print(product) # 120 (1*2*3*4*5) # Find maximum maximum = reduce(lambda a, b: a if a > b else b, numbers) print(maximum) # 5 # Concatenate strings words = ["Hello", "World", "Python"] sentence = reduce(lambda a, b: a + " " + b, words) print(sentence) # Hello World Python # With initial value (starts with 100) total_with_start = reduce(lambda a, b: a + b, numbers, 100) print(total_with_start) # 115 (100 + 15)

💬 Interview Q&A:

📘 Definition: A Decorator is a function that MODIFIES the behavior of another function WITHOUT changing its actual code. Decorators use the @decorator_name syntax placed above the function definition. They are commonly used for logging, timing, authentication, caching, and validation. Decorators are based on Python's ability to treat functions as "first-class citizens" — functions can be passed as arguments, returned from other functions, and assigned to variables.

🎯 Samjho Hinglish Mein: Decorator = function ke upar ek "wrapper" jo extra kaam karta hai bina original function ko modify kiye. Jaise cake ke upar cream lagana — cake same rehta hai, upar se decoration add ho jaata hai. Example: kisi function ke start aur end mein log messages add karne hain — har function mein manually print() likhne ki jagah, ek decorator banao aur @log laga do — done! Django/Flask mein @app.route(), testing mein @pytest.fixture — sab decorators hain.

💻 Examples:

# Example 1: Simple decorator — add logging def my_logger(func): def wrapper(*args, **kwargs): print(f"🔵 Calling: {func.__name__}") result = func(*args, **kwargs) # Call original print(f"🟢 Finished: {func.__name__}") return result return wrapper
# Apply decorator with @ syntax
@my_logger
def greet(name):
print(f"Hello, {name}!")

greet("Jatin")
# 🔵 Calling: greet
# Hello, Jatin!
# 🟢 Finished: greet

# Example 2: Timing decorator — measure execution time import time def measure_time(func):
     def wrapper(*args, **kwargs): start = time.time() result = func(*args, **kwargs) end = time.time() print(f"⏱️ {func.__name__} took {end-start:.4f} seconds") return result return wrapper @measure_time def slow_operation(): time.sleep(1) # Simulate slow work return "Done!" @measure_time def fast_operation():
     return sum(range(1000)) slow_operation() # ⏱️ slow_operation took 1.0012 seconds fast_operation() # ⏱️ fast_operation took 0.0001 seconds

# Example 3: Authentication decorator (real-world) current_user = {"role": "admin"} # Simulated logged-in user def requires_admin(func):
     def wrapper(*args, **kwargs):
     if current_user["role"] != "admin":
     print("❌ Access denied! Admin only.") return None return func(*args, **kwargs) return wrapper @requires_admin def delete_all_data():
     print("🗑️ All data deleted!") @requires_admin def view_reports():
     print("📊 Reports shown") delete_all_data() # 🗑️ All data deleted! view_reports() # 📊 Reports shown # Change user role — test again current_user["role"] = "guest" delete_all_data() # ❌ Access denied! Admin only.

💬 Interview Q&A:

📘 Definition: Docstrings are string literals placed as the FIRST statement in a function to describe what the function does. They are accessible via function.__doc__ and used by help(). Type Hints (Python 3.5+) allow you to specify the expected data types of parameters and return values using colons. They don't enforce types at runtime but help IDEs, linters, and other developers understand your code better.

🎯 Samjho Hinglish Mein: Docstring = function ka description — kya karta hai, kya inputs leta hai, kya return karta hai. Triple quotes mein likhte hain function ke andar first line par. Type Hints = function ke parameters aur return value ka data type explicitly batana — def add(a: int, b: int) -> int. Python actually check nahi karta types at runtime (dynamically typed hai) — lekin IDEs, editors, aur tools like mypy use karte hain warnings dene ke liye. Professional Python code mein type hints standard hain aaj kal.

💻 Examples:

# Example 1: Docstrings def calculate_area(radius): """ Calculate the area of a circle.
text

Args:
    radius (float): The radius of the circle.

Returns:
    float: The area of the circle (π × r²).

Example:
    >>> calculate_area(5)
    78.53981633974483
"""
import math
return math.pi * radius ** 2
# Access docstring
print(calculate_area.doc)

# Use built-in help()
help(calculate_area)
# Shows full documentation!

# Example 2: Type Hints (basic) def add(a: int, b: int) -> int: """Add two integers and return the sum.""" return a + b def greet(name: str, greeting: str = "Hello") -> str: """Return a greeting message.""" return f"{greeting}, {name}!" def is_adult(age: int) -> bool: """Check if a person is an adult.""" return age >= 18 def no_return_value() -> None: """This function doesn't return anything.""" print("Just printing...") # Type hints are NOT enforced at runtime! print(add("Hello", " World")) # Still runs → "Hello World" (Python doesn't check types) # But IDE will show warning!

# Example 3: Advanced Type Hints (professional code) from typing import List, Dict, Optional, Tuple, Union # List of integers def calculate_sum(numbers: List[int]) -> int: """Sum all numbers in a list.""" return sum(numbers) # Dictionary def process_user(user: Dict[str, any]) -> str: """Process user dictionary and return formatted string.""" return f"{user['name']} ({user['age']})" # Optional — value can be None def find_user(user_id: int) -> Optional[str]: """Return user name or None if not found.""" users = {1: "Jatin", 2: "Priya"} return users.get(user_id) # Returns None if not found # Union — accepts multiple types def display(value: Union[int, float, str]) -> None: """Display value regardless of type.""" print(f"Value: {value}") # Multiple returns as tuple def divide(a: int, b: int) -> Tuple[int, int]: """Return quotient and remainder.""" return a // b, a % b # Use them print(calculate_sum([1, 2, 3, 4, 5])) # 15 print(find_user(1)) # Jatin print(find_user(99)) # None q, r = divide(17, 5) print(f"Q: {q}, R: {r}") # Q: 3, R: 2

💬 Interview Q&A:

Next: Python Handbook — Part 9

Agle chapter mein hum cover karenge: File Handling & Exception Handling — open(), read/write files (txt, csv, json), with statement (context manager), try/except/finally, custom exceptions, raise statement. Real-world data processing ke liye critical topics. Part 1-8 Data Insights par available hain — Python Basics se lekar Functions tak complete deep dive.

Happy Learning & Keep Coding! 🚀