इस Python tutorial में हम सबसे पहले ये समझेंगे की functions क्या होते हैं और हम पाइथन में फंक्शन क्यों use करते हैं. इसके बाद हम Python में functions को define करना और functions को call करना सीखेंगे.
जब हम किसी बड़े project पर काम करते हैं तो उसमें कोई task (action) अलग-अलग जगह पर multiple times repeat हो सकता है लेकिन हम उस task के multi lines code (logic) को उन जगहों multiple times repeat (copy) नहीं करते हैं.
क्योंकि programming में एक rule बहुत ही strictly follow किया जाता है और वो है DRY (Don’t Repeat Yourself). इस rule का मतलब है ये होता है की हम अपने किसी एक program में अपने किसी भी code को repeat (copy) नहीं करेंगे.
Code repetition की वजह से हमारे program की readability, performance और maintenance पर बहुत ज्यादा बुरा असर पड़ता है. इस problem से बचने के लिए Python में functions का concept दिया गया है.
What is Functions in Python in Hindi
Function एक ऐसा block of reusable code होता है जो किसी specific task को perform करता है. दूसरे शब्दों में कहूँ तो function में हम किसी specific task के लिए किए गये statements (code) को एक name के साथ एक block (body) में group कर देते हैं.
Functions की help से हम एक बड़े complex program को task के basis पर छोटे-छोटे और reusable parts में divide कर देते हैं जिससे की program को आसानी से समझा और maintain किया जा सकें.
हम किसी task (action) के function को सिर्फ एक बार define करते हैं और फिर program में जहाँ-जहाँ हमें वो task perform कराना होता है हम उसके function को वहां पर call कर लेते हैं. Function को एक बार define करने के बाद आप उसे कभी भी कहीं भी call (use) कर सकते हो.
जब हम किसी function को अपने program में call करते हैं तो जहाँ-जहाँ भी हमने function को call किया है उन सभी जगहों पर वो task execute (run) हो जाएगा जिस task के लिए वो function आपने define किया है.
Types of Functions in Python
Python में दो तरह के functions होते हैं जिनके बारे में मैंने आपको नीचे समझाया है.
Built-in Functions:
Built-in functions को हम pre-defined functions भी कहते हैं क्योंकि ये functions Python में पहले से defined (मौजूद) होते हैं और इनकी help से हम बहुत से common task को बहुत ही जल्दी और आसानी से कर सकते हैं. print(), len(), range() और input() ये सब built-in functions के examples हैं.
User-defined Functions:
जैसा की ऊपर बताया की बहुत से common task के लिए तो Python में pre-defined functions होते हैं जिसकी वजह से हमें उन common task के लिए खुद से scratch (शुरुआत) से code नहीं करना पड़ता है.
लेकिन user-defined functions वो functions होते हैं जो programmers (user) के जरिए अपने programs के specific custom task के लिए बिल्कुल scratch से defined (code) किए जाते हैं. आइए अब सीखते हैं की Python में functions कैसे defined किए जाते हैं.
How to Define a User-Defined Function in Python
Python में functions defined करने का जो standard syntax उसे मैंने नीचे detail में explain किया है.
Python Function Syntax:
def function_name(parameters):
# function body
# What the function does goes here
# write some action
return result
1. def
Python में functions को define करने करने की शुरुआत def keyword से ही होती है.
2. function_name
जैसे हम variables को name assign करते हैं ठीख ऐसे ही function को भी उसके task (action) के according हम अपनी मर्जी से एक unique identifier (name) assign करते हैं और फिर इसी name की हेल्प से function को बाद में call करते हैं.
3. parameters
Function name के बाद parentheses () के बीच में हम 0 या उससे ज्यादा parameters include करते हैं. ये parameters basically variables होते हैं जिनको function calling के समय में values arguments के तौर पर pass (assign) की जाती है.
इसके बाद function body में हम इन parameters (variables) की values को किसी action को perform करने के लिए use करते हैं.
नोट: parentheses () के बाद : लगाना ना भूले.
4. function body
Function body एक indented block of code होता जिसमें किसी specific task को perform करने वाले statements होते हैं. आप जब-जब किसी function को call करते हैं तब-तब function body में मौजूद सभी statements को execute किए जाते हैं.
5. return result
बहुत बार ऐसा होता है की function में कोई task perform करने के बाद हम उसके result को function के अन्दर ही print कर देते हैं और बहुत बार ऐसा होता है की उस result value को वहां return करते हैं जहाँ से function को call किया गया है और इसके लिए हम return statement का use करते हैं.
6. pass statement
बहुत बार ऐसा होता है की हम सिर्फ function को define करते वक्त function body में कोई statements add नहीं करना चाहते हैं यानी कुछ वजह से हम function body को empty रखना चाहते हैं तो उसके लिए हम function body में pass statement लिख देते हैं.
def function_name():
pass
जैसा की आपने ऊपर देखा की किसी भी function को define करने से पहले हमें ये decide करना होता है की हमारा function कैसा होगा, क्या हमारे function में parameters होंगे की नहीं, क्या वो function काम करने के बाद कोई value हमें result के तौर पर return करेगा या नहीं.
ये सब decide करने के बाद ही आप नीचे दिए function definition types में से किसी एक type से अपने function को define करते हो.
- Function without return type without parameters
- Function without return type with parameters
- Function with return type without parameters
- Function with return type with parameters
अब हम एक-एक करके चारो function definition types से function को define करना और call करना सीखेंगे. मैंने नीचे एक simple addition task के function को चारों तरह से बनाकर दिखाया है.
Function without return type without parameters
def sum():
num1 = int(input("Enter First Number: "))
num2 = int(input("Enter Second Number: "))
total = num1 + num2
print("Total:",total)
sum()
Output:
Enter First Number: 25
Enter Second Number: 40
Total: 65
Function without return type with parameters
def sum(num1,num2):
total = num1 + num2
print("Total:",total)
a = int(input("Enter First Number: "))
b = int(input("Enter Second Number: "))
sum(a,b)
Output:
Enter First Number: 60
Enter Second Number: 20
Total: 80
Explanation:
ऊपर example program में हमने जो sum name से जो function define किया है उसमें 2 parameters है इसलिए function को call करते वक्त 2 values (arguments) pass करने ही होंगे इसलिए हमने भी variable a और b में 2 numbers इनपुट लेकर उन्हें function call में pass किया है.
Function with return type without parameters
def sum():
num1 = int(input("Enter First Number: "))
num2 = int(input("Enter Second Number: "))
total = num1 + num2
return total
result = sum()
print("Total:",result)
Output:
Enter First Number: 50
Enter Second Number: 15
Total: 65
Explanation:
जब हम किसी with return type function को call करते हैं तो function call को किसी variable को assign करते हैं और जब ये function कोई value return करेगा तो वो returned value उस variable को assign हो जाएगी जिसको हमने function call को assign किया था.
Function with return type with parameters
def sum(num1,num2):
total = num1 + num2
return total
a = int(input("Enter First Number: "))
b = int(input("Enter Second Number: "))
result = sum(a,b)
print('Total:',result)
illustration:
Output:
Enter First Number: 40
Enter Second Number: 30
Total: 70
Types of Arguments in Python
ये तो आप अभी तक समझ ही होंगे की वो values या variables जो हम किसी function को call करते वक्त उसके parameters को pass करते हैं उन्हें हम arguments कहते हैं.
Python में different types से arguments को pass किया जाता है जिनके बारे में हम अब एक-एक करके समझेंगे.
Required Positional Arguments
अगर किसी function parentheses ( ) में parameters को बिल्कुल simple तरीके से include किया गया है तो इस तरह के function को call करते वक्त हमें exactly उतने ही arguments pass करते होते हैं जितने variables हमने parameters के तौर पर function के parentheses में include किए हैं.
ये required positional arguments function parameters को उसी order (position) में assign होते हैं जिस order में आप इन्हें pass करते हैं जैसे की पहला argument पहले parameter को और दूसरा argument दुसरे parameter को.
अगर आप arguments parameters की गिनती से कम pass करेंगे तो आपको ‘missing argument’ का error show होगा. हमने ऊपर जो भी function के example programs बनायें उन सभी में required arguments का ही use किया है.
Keyword Arguments
जब function को call करते वक्त उसके arguments को parameter names को assign करके pass किया जाता है तो उन arguments को हम keyword arguments कहते हैं.
Keyword arguments का फायदा ये होता है की हम function arguments को किसी भी order में pass कर सकते हैं क्योंकि इनकी value उसी parameters को assign होगी जिससे इसका name match हो जाएगा.
Example:
def sayHello(fname, lname):
print("Hello", fname, lname)
sayHello(lname='Parmar',fname='Neeraj')
Output:
Hello Neeraj Parmar
Default Parameter Value
Python में function parentheses ( ) के अन्दर ही हम function parameters को assignment operator ( = ) की हेल्प से पहले से ही कोई default value assign कर सकते हैं.
अगर function call करते वक्त arguments pass नहीं किए तो function के अन्दर parameter की default value use होगी और अगर function call करते वक्त arguments pass किए जाते हैं तो pass किए गये arguments (value) default parameter value को overwrite (change) कर देंगी.
Example:
def multiply(a, b=1):
return a * b
t = multiply(2)
print('Multiply Result:', t)
t = multiply(2,3)
print('Multiply Result:', t)
Output:
Multiply Result: 2
Multiply Result: 6
Explanation:
जब हमने first time multiply function को call तब हमने सिर्फ एक argument pass किया है जो की parameter a को assign हो जायेगा और parameter b के पास default value 1 ही रहेगी.
लेकिन जब हम second time multiply function को call किया है तब हम 2 arguments (values) pass किए हैं. First argument की value first parameter a को assign होगी और second argument की value second parameter b की value को overwrite कर देगी यानी variable b की value इस बार 1 की जगह 3 होगी.
Arbitrary Arguments (*args)
बहुत बार हमें ऐसा function define करना होता है जिसे call करते वक्त कितने भी (Arbitrary) arguments pass किए जा सकें तो इसके लिए हम function में parameter name के आगे asterisk ( * ) लगा देते हैं.
जब हम ऐसा करते तो हम function को call करते वक्त कितने भी arguments pass कर सकते हैं और ये सभी arguments हमारे function के arbitrary parameter में tuple के तौर पर store हो जाते हैं.
Example 1:
def myFun(*numbers):
print(numbers)
myFun(80,90)
myFun(10,20,30,40,50)
Output:
(80, 90)
(10, 20, 30, 40, 50)
Example 2:
def myFun(*numbers):
total = 0
for ele in numbers:
total = total + ele
print("Total:", total)
myFun(80,90)
myFun(10,20,30,40,50)
Output:
Total: 170
Total: 150
Arbitrary Keyword Arguments (**kwargs)
बहुत बार हमें ऐसा function define करना होता है जिसे call करते वक्त कितने भी (Arbitrary) keyword arguments pass किए जा सकें तो इसके लिए हम function में parameter name के आगे double asterisk ( ** ) लगा देते हैं.
जब हम ऐसा करते तो हम function को call करते वक्त कितने भी keyword arguments pass कर सकते हैं और ये सभी arguments हमारे function के arbitrary parameter में dictionary के तौर पर store हो जाते हैं.
Example:
def display(**data):
for key, value in data.items():
print(f"{key}: {value}")
display(roll=101,name='Karan Sharma',cgpa=8.9)
Output:
roll: 101
name: Karan Sharma
cgpa: 8.9