फ़ंक्शन क्यों? बिल्ट-इन, मॉड्यूल और यूज़र-डिफ़ाइंड
फ़ंक्शन एक नाम वाला कोड-खंड है जो एक काम करता है। इससे एक ही कोड बार-बार नहीं लिखना पड़ता, और प्रोग्राम पढ़ना-सुधारना आसान होता है।
- बिल्ट-इन फ़ंक्शन हमेशा तैयार रहते हैं:
print(),input(),len(),int(),type(),max(),round()। - मॉड्यूल के फ़ंक्शन: मॉड्यूल तैयार कोड की फ़ाइल है। पहले
importकरें।import mathफिरmath.sqrt(16);from random import randintफिरrandint(1, 6)।statisticsमॉड्यूल में mean, median, mode हैं। - यूज़र-डिफ़ाइंड फ़ंक्शन: आप
defसे बनाते हैं।
def greet(name):
print('Hello', name)
greet('Asha')पहली पंक्ति हेडर है (अंत में कोलन)। खिसकी हुई (indented) पंक्तियाँ बॉडी हैं।
पैरामीटर और आर्ग्युमेंट
पैरामीटर वह नाम है जो def पंक्ति में लिखा होता है। आर्ग्युमेंट वह असली मान है जो कॉल में भेजा जाता है। def area(l, b) में l और b पैरामीटर हैं। area(5, 3) में 5 और 3 आर्ग्युमेंट हैं।
आर्ग्युमेंट को वास्तविक पैरामीटर और पैरामीटर को औपचारिक पैरामीटर भी कहते हैं।
पोज़िशनल, कीवर्ड और डिफ़ॉल्ट आर्ग्युमेंट
पोज़िशनल आर्ग्युमेंट
स्थान से मिलते हैं: पहला आर्ग्युमेंट → पहला पैरामीटर। power(2, 3) यानी base = 2, exp = 3। संख्या बराबर होनी चाहिए।
डिफ़ॉल्ट आर्ग्युमेंट
पैरामीटर का पहले से तय मान: def power(base, exp=2):। अब power(5) = 25 और power(5, 3) = 125। नियम: डिफ़ॉल्ट वाले पैरामीटर बिना डिफ़ॉल्ट वालों के बाद आएँ। def f(a=1, b): एरर है।
कीवर्ड आर्ग्युमेंट
कॉल में पैरामीटर का नाम लिख सकते हैं: power(exp=3, base=2)। तब क्रम से फ़र्क नहीं पड़ता। कॉल में पोज़िशनल आर्ग्युमेंट कीवर्ड वालों से पहले आते हैं।
मान लौटाना (return)
return फ़ंक्शन ख़त्म करता है और मान को वहाँ भेजता है जहाँ से कॉल हुआ था।
def square(n):
return n * n
ans = square(4) # ans = 16- बिना
returnवाला फ़ंक्शन (void)Noneलौटाता है। - एक साथ कई मान लौटा सकते हैं; वे ट्यूपल बनकर आते हैं:
return s, p→(s, p)। - उसी खंड में
returnके बाद की पंक्तियाँ कभी नहीं चलतीं।
निष्पादन का क्रम (flow of execution)
पायथन ऊपर से नीचे चलता है। def खंड केवल पढ़कर याद रखा जाता है; उसकी बॉडी तब नहीं चलती। कॉल आने पर नियंत्रण फ़ंक्शन में कूदता है, उसे चलाता है और return (या बॉडी के अंत) पर कॉल वाली पंक्ति पर लौट आता है। कॉल वाली पंक्ति से पहले फ़ंक्शन डिफ़ाइन होना ज़रूरी है।
1 def add(a, b): 2 return a + b 3 x = 4 4 y = add(x, 6) 5 print(y)
क्रम: 1 → 3 → 4 → 1 → 2 → 4 → 5। आउटपुट: 10।
स्कोप: लोकल और ग्लोबल वेरिएबल
स्कोप प्रोग्राम का वह हिस्सा है जहाँ कोई नाम इस्तेमाल हो सकता है।
- लोकल वेरिएबल फ़ंक्शन के अंदर बनता है। फ़ंक्शन चलने तक ही रहता है और बाहर नहीं दिखता।
- ग्लोबल वेरिएबल सब फ़ंक्शनों के बाहर बनता है। किसी भी फ़ंक्शन में पढ़ा जा सकता है।
- फ़ंक्शन के अंदर किसी नाम को मान देते ही पायथन नया लोकल नाम बना देता है, चाहे उसी नाम का ग्लोबल हो।
- अंदर से ग्लोबल बदलना हो तो पहले
global xलिखें।
x = 10
def f():
x = 5 # नया लोकल x
print(x) # 5
f(); print(x) # 10
def g():
global x
x = 99
g(); print(x) # 99पायथन नाम इस क्रम में खोजता है: लोकल → एनक्लोज़िंग → ग्लोबल → बिल्ट-इन (LEGB नियम)।
लिस्ट भेजना
लिस्ट भेजकर अंदर append करें तो बाहर भी बदलाव दिखता है (लिस्ट म्यूटेबल है, वही ऑब्जेक्ट साझा है)। int भेजकर अंदर n += 1 करने से बाहर वाला int नहीं बदलता।
करके देखें: बिल मशीन बनाइए
def bill(price, qty=1, gst=18): लिखिए जो कुल रकम लौटाए। चलाने से पहले bill(100), bill(100, 3) और bill(100, gst=5) का उत्तर अनुमान से लिखिए। फिर चलाकर मिलाइए। अब फ़ंक्शन के बाहर print(price) लिखिए और NameError देखिए: price लोकल है।
मुख्य सूत्र और परिभाषाएँ
- def नाम(पैरामीटर): बॉडी → नाम(आर्ग्युमेंट)
- डिफ़ॉल्ट पैरामीटर अंत में: def f(a, b=2, c=3)
- return नहीं → None; return a, b → ट्यूपल
- नाम खोज: लोकल → एनक्लोज़िंग → ग्लोबल → बिल्ट-इन (LEGB)
हल किए गए उदाहरण
1. पैरामीटर और आर्ग्युमेंट पहचानिए: def area(l, b): return l*b ... print(area(7, 4))
पैरामीटर: l और b (def पंक्ति में)। आर्ग्युमेंट: 7 और 4 (कॉल में)। आउटपुट: 28।
2. def power(base, exp=2): return base ** exp। power(3), power(3, 3), power(exp=0, base=9) बताइए।
power(3): exp डिफ़ॉल्ट 2 → 9। power(3, 3) → 27। power(exp=0, base=9): नाम से मिले → 9 ** 0 = 1।
3. कौन-से हेडर सही हैं? (a) def f(a, b=1) (b) def f(a=1, b) (c) def f(a=1, b=2)
(a) सही। (b) गलत: डिफ़ॉल्ट वाले के बाद बिना डिफ़ॉल्ट पैरामीटर नहीं आ सकता। (c) सही।
4. निष्पादन क्रम लिखिए: 1 def sq(n): 2 return n*n 3 a = 3 4 print(sq(a) + 1)
1 (def याद) → 3 → 4 (कॉल) → 1 → 2 (9 लौटा) → 4 (10 छपा)।
5. x = 5 def f(): x = 20 print('in', x) f() print('out', x)
f के अंदर x = 20 से लोकल x बना। आउटपुट: in 20, फिर out 5। ग्लोबल x नहीं बदला।
6. एक फ़ंक्शन stats(L) लिखिए जो लिस्ट का योग और औसत लौटाए। [4, 8, 6] के लिए चलाइए।
def stats(L): s = sum(L) return s, s / len(L) t, a = stats([4, 8, 6]) print(t, a) # 18 6.0
7. c = 0 def inc(): global c c += 1 inc(); inc(); print(c)
global c से फ़ंक्शन ग्लोबल c बदल पाता है। दो कॉल = दो बार +1। आउटपुट: 2। global के बिना UnboundLocalError आता।
आम गलतियाँ
- पैरामीटर (def में) और आर्ग्युमेंट (कॉल में) को एक मान लेना।
- डिफ़ॉल्ट पैरामीटर को बिना डिफ़ॉल्ट वाले से पहले रखना: def f(a=1, b)।
- फ़ंक्शन में print करके मान वापस मिलने की उम्मीद करना; मान भेजने के लिए return लिखें।
- global लिखे बिना फ़ंक्शन में ग्लोबल बदलना (नया लोकल बनता है या UnboundLocalError आता है)।