रुपेश पवार
IT Professional 5+ वर्षांचा अनुभव
प्रकाशित
23 May’२०२६
वाचण्याचा वेळ
12 मिनिटे
स्तर
Beginner
Python Functions हे programming चा backbone आहे! एकदा function लिहिला की तो हजारो वेळा वापरता येतो. या blog मध्ये def पासून ते Decorators पर्यंत – सर्व 13 topics मराठीत, real Maharashtra examples सह.
Table of Contents
Python Function म्हणजे काय? | मराठीत सोपे उदाहरण
कल्पना करा तुम्हाला रोज सकाळी चहा बनवायचा आहे. प्रत्येक वेळी पाणी उकळणे → दूध घालणे → चहापत्ती → साखर, या steps करायला वेळ जातो. जर तुम्ही एकदा “चहा बनवण्याची recipe” कुठेतरी लिहून ठेवली आणि रोज फक्त “चहा बनव!” असे सांगितले तर? Python Functions हेच करतात!
‘Function’ म्हणजे काय?
Python Function म्हणजे एकदा लिहिलेला code जो वारंवार वेगळ्या inputs सह वापरता येतो. Functions मुळे code: (1) Reusable होतो, (2) readable होतो, (3) Easy to debug होतो, (4) Organized राहतो.
1. Code Reusability: एकदा लिहा, हजारो वेळा वापरा
2. Modular Code: मोठा program छोट्या functions मध्ये divide करा.
3. Easy Debugging: error एका function मध्ये fix केला की सर्वत्र fix.
4. Readable Code: function नाव वाचून code समजतो.
5. Encapsulation: logic एका जागी ठेवा, बाहेर फक्त result.
6. Team Work: वेगळे functions वेगळे developers लिहू शकतात
def Keyword – Function बनवणे
Python मध्ये function बनवण्यासाठी def keyword वापरतो. def म्हणजे “define” — आपण function ची definition देतो.
Function Syntax:
def function_name(parameters):
“””Docstring — function काय करतो”””
# function body
return value
# साधे function — कोणतेही parameters नाहीत
def नमस्कार():
"""हे function नमस्कार message print करते"""
print("नमस्कार! lgrow.in वर स्वागत आहे.")
print("Python शिकूया मराठीत!")
# Function call करा
नमस्कार()
नमस्कार() # एकाच function ला अनेक वेळा call करता येतेनमस्कार! lgrow.in वर स्वागत आहे. Python शिकूया मराठीत! नमस्कार! lgrow.in वर स्वागत आहे. Python शिकूया मराठीत!
Function Call – Parameters सह
# Parameters सह function
def विद्यार्थी_परिचय(नाव, वय, शहर):
"""विद्यार्थ्याचा परिचय print करते"""
print(f"नाव: {नाव}")
print(f"वय: {वय} वर्षे")
print(f"शहर: {शहर}")
print("-"*25)
# Different inputs सह call करा
विद्यार्थी_परिचय("राहुल पाटील", 21, "पुणे")
विद्यार्थी_परिचय("प्रिया शर्मा", 20, "मुंबई")
विद्यार्थी_परिचय("अमित देशमुख", 22, "नाशिक")नाव: राहुल पाटील वय: 21 वर्षे शहर: पुणे ------------------------- नाव: प्रिया शर्मा वय: 20 वर्षे शहर: मुंबई -------------------------
Function Arguments चे 4 Types
Python मध्ये function ला argument pass करण्याचे 4 वेगळे प्रकार आहेत. हे Interview मध्ये खूप विचारले जातात!
1. Positional Arguments
Order प्रमाणे values pass होतात. पहिला argument पहिल्या parameter ला, दुसरा दुसऱ्याला.
2. Keyword Arguments
नावाने values pass करतात. Order महत्त्वाचा नाही, नाव बरोबर असणे जरुरी.
3. Default Arguments
Parameter ला default value असते. Call मध्ये value न दिल्यास default वापरतो.
4. *args / **kwargs
Variable number of arguments. *args=tuple, **kwargs=dictionary.
Default Arguments
# Default argument — value न दिल्यास default वापरतो
def MSEB_bill(units, rate=7.50, tax=0.18):
"""MSEB वीज बिल calculate करतो"""
base = units * rate
gst = base * tax
total = base + gst
print(f"Units: {units} | Rate: ₹{rate} | GST: ₹{gst:.2f} | Total: ₹{total:.2f}")
# फक्त units दिला — rate आणि tax default वापरतात
MSEB_bill(200)
# Custom rate दिला
MSEB_bill(500, rate=10.00)
# सर्व custom
MSEB_bill(100, rate=3.50, tax=0.05)
# Greet function — default name
def greet(नाव="विद्यार्थी", भाषा="मराठी"):
print(f"नमस्कार {नाव}! {भाषा} मध्ये Python शिकत आहात.")
greet() # दोन्ही default
greet("राहुल") # फक्त नाव दिला
greet("Priya", "English") # दोन्ही customUnits: 200 | Rate: ₹7.5 | GST: ₹270.00 | Total: ₹1770.00 Units: 500 | Rate: ₹10.0 | GST: ₹900.00 | Total: ₹5900.00 Units: 100 | Rate: ₹3.5 | GST: ₹17.50 | Total: ₹367.50 नमस्कार विद्यार्थी! मराठी मध्ये Python शिकत आहात. नमस्कार राहुल! मराठी मध्ये Python शिकत आहात. नमस्कार Priya! English मध्ये Python शिकत आहात.
Keyword Arguments
def student_profile(नाव, वय, शाखा, grade):
print(f"{नाव} | {वय} वर्षे | {शाखा} | Grade: {grade}")
# Positional — order जरुरी
student_profile("राहुल", 21, "CS", "A")
# Keyword — order ची गरज नाही!
student_profile(grade="A+", नाव="प्रिया", शाखा="IT", वय=20)
# Mix: Positional + Keyword
student_profile("अमित", 22, grade="B", शाखा="Mech")राहुल | 21 वर्षे | CS | Grade: A प्रिया | 20 वर्षे | IT | Grade: A+ अमित | 22 वर्षे | Mech | Grade: B
*args आणि **kwargs
*args आणि **kwargs हे Python functions मधील सर्वात powerful features आहेत. Interviews मध्ये हे नक्की विचारतात!
*args vs **kwargs:
• *args — Variable number of positional arguments → Tuple म्हणून मिळतो
• **kwargs — Variable number of keyword arguments → Dictionary म्हणून मिळतो
• * आणि ** फक्त convention आहे — नाव काहीही देता येते, पण args/kwargs हे standard आहे
# *args — कितीही positional arguments
def marks_total(*args):
"""कितीही subjects चे marks घ्या"""
print(f"Marks received: {args}")
print(f"Type: {type(args)}") # tuple!
एकूण = sum(args)
सरासरी = एकूण / len(args)
print(f"एकूण: {एकूण} | सरासरी: {सरासरी:.1f}%")
print()
marks_total(85, 92, 78) # 3 subjects
marks_total(90, 88, 95, 82, 87) # 5 subjects
# Regular + *args
def student_marks(नाव, *marks):
एकूण = sum(marks)
print(f"{नाव}: एकूण = {एकूण}, सरासरी = {एकूण/len(marks):.1f}%")
student_marks("राहुल", 85, 90, 78)
student_marks("प्रिया", 92, 88, 95, 90)Marks received: (85, 92, 78) Type: <class 'tuple'> एकूण: 255 | सरासरी: 85.0% Marks received: (90, 88, 95, 82, 87) Type: <class 'tuple'> एकूण: 442 | सरासरी: 88.4% राहुल: एकूण = 253, सरासरी = 84.3% प्रिया: एकूण = 365, सरासरी = 91.2%
# **kwargs — कितीही keyword arguments
def विद्यार्थी_माहिती(**kwargs):
"""कोणतीही माहिती pass करा"""
print(f"Type: {type(kwargs)}") # dict!
print("=== विद्यार्थी Profile ===")
for key, value in kwargs.items():
print(f" {key}: {value}")
विद्यार्थी_माहिती(नाव="राहुल", वय=21, शहर="पुणे")
print()
विद्यार्थी_माहिती(नाव="प्रिया", वय=20, शाखा="CS", grade="A+", scholarship=True)
# *args + **kwargs एकत्र
def complete_info(*args, **kwargs):
print(f"Positional: {args}")
print(f"Keyword: {kwargs}")
complete_info(1, 2, 3, नाव="राहुल", शहर="पुणे")Type: <class 'dict'>
=== विद्यार्थी Profile ===
नाव: राहुल
वय: 21
शहर: पुणे
Type: <class 'dict'>
=== विद्यार्थी Profile ===
नाव: प्रिया
वय: 20
शाखा: CS
grade: A+
scholarship: True
Positional: (1, 2, 3)
Keyword: {'नाव': 'राहुल', 'शहर': 'पुणे'}return Statement – Value परत देणे
# Single return value
def square(n):
return n ** 2
result = square(7)
print(f"7² = {result}")
# Multiple return values (tuple)
def min_max_avg(numbers):
return min(numbers), max(numbers), sum(numbers)/len(numbers)
marks = [85, 92, 78, 90, 88]
कमीत_कमी, सर्वाधिक, सरासरी = min_max_avg(marks)
print(f"Min: {कमीत_कमी} | Max: {सर्वाधिक} | Avg: {सरासरी:.1f}")
# Early return — condition नुसार
def grade_check(marks):
if marks < 35:
return "FAIL" # early return
if marks >= 90: return "A+"
if marks >= 80: return "A"
if marks >= 70: return "B"
return "C"
for m in [95, 82, 72, 55, 30]:
print(f"Marks {m}: {grade_check(m)}")7² = 49 Min: 78 | Max: 92 | Avg: 86.6 Marks 95: A+ Marks 82: A Marks 72: B Marks 55: C Marks 30: FAIL
Lambda Functions – Anonymous Functions
Lambda म्हणजे एकाच ओळीत, नावाशिवाय function बनवणे. Interview मध्ये lambda + map() + filter() हे combination नक्की विचारतात!
# Lambda syntax: lambda arguments: expression
square = lambda x: x ** 2
add = lambda a, b: a + b
greet = lambda name: f"नमस्कार {name}!"
print(square(5)) # 25
print(add(10, 20)) # 30
print(greet("राहुल")) # नमस्कार राहुल!
# Lambda + sorted() — marks नुसार sort
विद्यार्थी = [
("राहुल", 85), ("प्रिया", 95), ("अमित", 72), ("सुमित", 88)
]
sorted_list = sorted(विद्यार्थी, key=lambda x: x[1], reverse=True)
print("\nMarks Ranking:")
for i, (नाव, marks) in enumerate(sorted_list, 1):
print(f" {i}. {नाव}: {marks}%")
# Lambda + map() — सर्व marks वर operation
marks_list = [40, 55, 70, 85]
# प्रत्येक mark ला 5 bonus देऊ
bonus_marks = list(map(lambda x: x + 5, marks_list))
print(f"\nOriginal: {marks_list}")
print(f"After Bonus: {bonus_marks}")
# Lambda + filter() — pass झालेले students
all_marks = [28, 45, 72, 30, 88, 55]
passed = list(filter(lambda x: x >= 35, all_marks))
print(f"\nAll marks: {all_marks}")
print(f"Passed (35+): {passed}")25 30 नमस्कार राहुल! Marks Ranking: 1. प्रिया: 95% 2. सुमित: 88% 3. राहुल: 85% 4. अमित: 72% Original: [40, 55, 70, 85] After Bonus: [45, 60, 75, 90] All marks: [28, 45, 72, 30, 88, 55] Passed (35+): [45, 72, 88, 55]
Nested Functions – Function आत Function
# Inner function — बाहेरच्या function च्या variable access करतो
def outer_function(x):
"""Outer function"""
message = f"Outer: x = {x}"
def inner_function(y):
"""Inner function — outer चे variables access करू शकतो"""
print(message) # outer variable access!
print(f"Inner: y = {y}")
print(f"Sum: {x + y}") # outer x access!
inner_function(10)
outer_function(5)
# Practical: Discount calculator
def price_calculator(original_price):
def with_discount(discount_percent):
discount = original_price * discount_percent / 100
return original_price - discount
def with_gst(gst_percent):
gst = original_price * gst_percent / 100
return original_price + gst
print(f"Original: ₹{original_price}")
print(f"10% Discount: ₹{with_discount(10):.2f}")
print(f"18% GST: ₹{with_gst(18):.2f}")
price_calculator(1000)outer: x = 5 Inner: y = 10 Sum: 15 Original: ₹1000 10% Discount: ₹900.00 18% GST: ₹1180.00
Recursive Functions — Function स्वतःला Call करतो NEW
Recursive function म्हणजे function जो स्वतःला call करतो. Factorial, Fibonacci, tree traversal — हे सर्व recursion वापरतात. Interview मध्ये हे नक्की विचारतात!
⚠ Base case जरुरी! Recursion मध्ये नेहमी base case असणे जरुरी आहे — नाहीतर infinite loop होतो आणि RecursionError येतो.
# 1. Factorial — n! = n × (n-1) × ... × 1
def factorial(n):
if n == 0 or n == 1: # Base case
return 1
return n * factorial(n - 1) # Recursive call
for i in [0, 1, 5, 10]:
print(f"{i}! = {factorial(i)}")
# 2. Fibonacci Series
def fibonacci(n):
if n <= 1: # Base case
return n
return fibonacci(n-1) + fibonacci(n-2)
print("\nFibonacci series:")
print([fibonacci(i) for i in range(10)])
# 3. Sum of digits
def digit_sum(n):
if n < 10: # Base case
return n
return (n % 10) + digit_sum(n // 10)
print(f"\n1234 चा digit sum: {digit_sum(1234)}") # 10
print(f"9876 चा digit sum: {digit_sum(9876)}") # 300! = 1 1! = 1 5! = 120 10! = 3628800 Fibonacci series: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34] 1234 चा digit sum: 10 9876 चा digit sum: 30
Decorators – Function वर Extra Feature
Decorator म्हणजे एखाद्या function ला “wrap” करून त्याला extra functionality देणे — original function न बदलता! @ symbol वापरतो.
# Simple Decorator — function च्या आधी/नंतर काहीतरी करा
def greeting_decorator(func):
def wrapper(*args, **kwargs):
print("=== Function सुरू होत आहे ===")
result = func(*args, **kwargs) # original function call
print("=== Function संपले ===")
return result
return wrapper
# @ symbol वापरून decorator apply करा
@greeting_decorator
def calculate_bill(amount, discount):
final = amount * (1 - discount/100)
print(f"Bill: ₹{amount} → After {discount}% discount: ₹{final:.2f}")
return final
calculate_bill(1000, 10)
# Timer Decorator — function किती वेळात चालतो
import time
def timer(func):
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"⏱ Time: {(end-start)*1000:.2f}ms")
return result
return wrapper
@timer
def sum_numbers(n):
return sum(range(n))
result = sum_numbers(1000000)
print(f"Sum: {result}")=== Function सुरू होत आहे === Bill: ₹1000 → After 10% discount: ₹900.00 === Function संपले === ⏱ Time: 42.18ms Sum: 499999500000
Real-World Projects – 5 Complete Examples
Project 1: Student Grade System (सर्व concepts एकत्र)
# सर्व function concepts एकत्र
def calculate_grade(marks, passing=35): # default arg
if marks < passing: return "F", "FAIL"
if marks >= 90: return "A+", "Outstanding"
if marks >= 80: return "A", "Excellent"
if marks >= 70: return "B", "Good"
if marks >= 60: return "C", "Average"
return "D", "Pass"
def print_report(नाव, roll, *marks, school="ज्ञानदीप"): # *args + keyword
एकूण = sum(marks)
सरासरी = एकूण / len(marks)
grade, शेरा = calculate_grade(सरासरी) # multiple return
print(f"\n{'='*40}")
print(f" {school} — Report Card")
print(f"{'='*40}")
print(f" Roll: {roll} | नाव: {नाव}")
print(f" Marks: {marks}")
print(f" एकूण: {एकूण} | सरासरी: {सरासरी:.1f}%")
print(f" Grade: {grade} — {शेरा}")
print_report("राहुल", 101, 85, 92, 78, 90, 88)
print_report("प्रिया", 102, 95, 98, 92, school="सरस्वती विद्यालय")======================================== ज्ञानदीप — Report Card ======================================== Roll: 101 | नाव: राहुल Marks: (85, 92, 78, 90, 88) एकूण: 433 | सरासरी: 86.6% Grade: A — Excellent ======================================== सरस्वती विद्यालय — Report Card ======================================== Roll: 102 | नाव: प्रिया Marks: (95, 98, 92) एकूण: 285 | सरासरी: 95.0% Grade: A+ — Outstanding
सामान्य चुका
1. Return नंतर Code लिहिणे:
return नंतरचा code कधीच execute होत नाही. ते “dead code” आहे. return आधी सर्व logic लिहा.
2. Default Mutable Argument:
def func(lst=[]) — list default argument म्हणून वापरू नका! Shared state येतो. def func(lst=None): if lst is None: lst=[] वापरा.
3. Recursion Base Case नाही:
Base case नसेल तर infinite recursion → RecursionError. नेहमी “काय झाल्यावर थांबायचे” हे आधी define करा.
4. *args नंतर Positional:
def func(*args, x) — After *args, a positional argument cannot be placed. Keyword-only arguments can be kept.
5. Function Not Called:
print हे function reference आहे, print() हे function call आहे. Parentheses विसरल्यास function execute होत नाही.
6. Best Practice:
Functions ला meaningful names द्या. Docstring नेहमी लिहा. एक function एकच काम करो (Single Responsibility). Functions छोटे ठेवा — 20 lines पेक्षा जास्त नको.
Practice Problems
1. Universal Calculator
*args वापरून function बनवा जो कितीही numbers घेतो. keyword arguments वापरून operation (“add”,”multiply”,”max”) निवडता येईल. Default operation: “add”.
2. Fibonacci with Memoization
Recursive Fibonacci बनवा. मग **kwargs वापरून “memo” dictionary pass करा. Memoization वापरून speed compare करा — fibonacci(30) किती faster होते ते बघा.
3. Lambda Chain
Lambda functions वापरून: (1) marks list फिल्टर करा (>60), (2) प्रत्येकाला 5 bonus द्या, (3) marks नुसार sort करा. फक्त lambda, map(), filter(), sorted() वापरा.
4. Login Decorator
@login_required नावाचा decorator बनवा. is_logged_in = True/False variable check करा. Logged in असेल तरच function execute होईल. नाहीतर “Please login first!” message.
सामान्य प्रश्न (FAQ)
Q1. *args आणि **kwargs मध्ये काय फरक आहे?
Ans: *args: Variable number of positional arguments — tuple म्हणून मिळतो. def func(*args): print(args) → (1,2,3) tuple. **kwargs: Variable number of keyword arguments — dictionary म्हणून मिळतो. def func(**kwargs): print(kwargs) → {‘key’:’value’} dict. Order: normal args → *args → keyword-only → **kwargs.
Q2. Default Arguments कधी वापरायचे?
Ans: Default arguments तेव्हा वापरतो जेव्हा parameter ची value बहुतेक वेळा एकच असते. उदा: GST rate नेहमी 18% असतो — def calculate(amount, gst=0.18). Default arguments नेहमी non-default arguments नंतर लिहावेत — def func(a, b=10) ✓, def func(a=10, b) ✗.
Q3. Lambda Function कधी वापरायचे?
Ans: Lambda तेव्हा वापरतो जेव्हा: (1) Function simple आणि एकाच line मध्ये लिहिता येतो, (2) Function एकाच ठिकाणी वापरायचे असते, (3) map(), filter(), sorted() च्या key argument साठी. Complex logic साठी नेहमी regular def function वापरा — lambda readable नाही.
Q4. Recursion कधी वापरायचे आणि कधी नाही?
Ans: वापरावे: Mathematical problems (factorial, Fibonacci), Tree/Graph traversal, divide and conquer algorithms, when the problem itself is divided into sub-problems. वापरू नये: Simple loops ने solve होणाऱ्या problems (recursion slower आणि memory जास्त). Python recursion limit 1000 आहे — खूप deep recursion avoid करा
Q5. Decorator म्हणजे काय?
Ans: Decorator म्हणजे एखाद्या function ला wrap करून त्याला extra functionality देणे — original function न बदलता. @ symbol वापरतो. उदाहरणे: @login_required (access control), @timer (performance), @cache (speed). Python built-in decorators: @staticmethod, @classmethod, @property.
Q6. Function Interview मध्ये काय विचारतात?
Ans: Interview मध्ये हे जरूर तयार करा: (1) *args vs **kwargs फरक, (2) Lambda vs def फरक. (3) Default mutable arguments का avoid करावे, (4) Recursion vs. Iteration: कधी वापरावे? (5) Decorator म्हणजे काय, (6) Pass by reference vs value, (7) Closure म्हणजे काय, (8) First-class functions म्हणजे काय.
पुढे काय शिकाल?
