7.1 परिचय

अब तक हमने कुछ प्रोग्राम लिखे हैं और शायद यह महसूस किया होगा कि जैसे-जैसे समस्या जटिल होती जाती है, प्रोग्राम में पंक्तियों की संख्या बढ़ जाती है, जिससे प्रोग्राम भारी लगने लगता है और प्रबंधित करना कठिन हो जाता है। निम्नलिखित समस्या कथन पर विचार करें:

एक कंपनी है जो उपयोगकर्ता की आवश्यकताओं के अनुसार तंबू बनाती है। तंबू का आकार बेलनाकार है जिसके ऊपर शंक्वाकार शीर्ष है।

चित्र 7.1: तंबू का आकार

“एक बार जब आप इन जटिल एल्गोरिदमों के लिए प्रोग्राम लिखने में सफल हो जाते हैं, तो वे आमतौर पर बेहद तेजी से चलते हैं। कंप्यूटर को एल्गोरिदम को समझने की जरूरत नहीं होती, उसका कार्य केवल प्रोग्राम चलाना होता है।”

$\quad$ -आर. तार्जन

कंपनी प्रत्येक तंबू के विक्रय मूल्य को निर्धारित करने के लिए निम्नलिखित कार्य करती है।

1. तंबू के लिए उपयोगकर्ता की आवश्यकताएँ स्वीकार करें, जैसे कि

$\qquad$ a) ऊँचाई

$\qquad$ b) त्रिज्या

$\qquad$ c) शंक्वाकार भाग की तिर्यक ऊँचाई

2. उपयोग किए गए कैनवस का क्षेत्रफल गणना करें
3. तंबू बनाने के लिए उपयोग किए गए कैनवस की लागत गणना करें
4. ग्राहक द्वारा देय कुल राशि गणना करें जिसमें 18% कर शामिल है

कंपनी ने देय राशि की तेज और सटीक गणना के लिए एक कंप्यूटर प्रोग्राम बनाया है जैसा कि प्रोग्राम 7-1 में दिखाया गया है।

प्रोग्राम 7-1 टेंट के लिए देय राशि की गणना करने के लिए प्रोग्राम।

#प्रोग्राम 7-1
#फंक्शन्स के बिना टेंट के लिए देय राशि की गणना करने के लिए प्रोग्राम

print( “टेंट के बेलनाकार भाग के लिए मान मीटर में दर्ज करें\n”)
h = float(input(“बेलनाकार भाग की ऊँचाई दर्ज करें: “))
r = float(input(“त्रिज्या दर्ज करें: “))

l = float(input(“शंक्वाकार भाग की तिरछी ऊँचाई मीटर में दर्ज करें: “))
csa_conical = 3.14rl $\hspace{1.5cm}$ #शंक्वाकार भाग का क्षेत्रफल
csa_cylindrical = 23.14r*h $\qquad$ #बेलनाकार भाग का क्षेत्रफल

#टेंट बनाने में प्रयोग होने वाले कैनवास का क्षेत्रफल की गणना करें
canvas_area = csa_conical + csa_cylindrical
print(“कैनवास का क्षेत्रफल है”,canvas_area,“m^2”)

#कैनवास की लागत की गणना करें
unit_price = float(input(“1 m^2 कैनवास की लागत दर्ज करें: “))
total_cost= unit_price * canvas_area
print(“कैनवास की कुल लागत = “,total_cost)

#ग्राहक द्वारा देय कुल राशि की गणना के लिए कुल लागत में कर जोड़ें
tax = 0.18 * total_cost;
net_price = total_cost + tax
print(“देय कुल राशि = “,net_price)

उपरोक्त समस्या को हल करने का एक अन्य दृष्टिकोण प्रोग्राम को विभिन्न कोड ब्लॉकों में विभाजित करना है जैसा कि चित्र 7.2 में दिखाया गया है।

चित्र 7.2: टेंट की लागत की गणना

कंप्यूटर प्रोग्राम को स्वतंत्र कोड के ब्लॉकों या अलग-अलग उप-समस्याओं में विभाजित करना, जिनके अलग नाम और विशिष्ट कार्यक्षमता होती है, को मॉड्यूलर प्रोग्रामिंग कहा जाता है। इस अध्याय में हम इस दृष्टिकोण के लाभों के बारे में सीखेंगे।

7.2 फंक्शन

प्रोग्रामिंग में, फंक्शन का उपयोग मॉड्यूलरता और पुन: उपयोगिता प्राप्त करने के साधनों में से एक है। फंक्शन को निर्देशों के एक नामित समूह के रूप में परिभाषित किया जा सकता है जो आमंत्रित होने पर एक विशिष्ट कार्य पूरा करता है। एक बार परिभाषित होने के बाद, एक फंक्शन को प्रोग्राम के विभिन्न स्थानों से बार-बार बुलाया जा सकता है बिना उस फंक्शन के सभी कोडों को हर बार लिखे, या इसे किसी अन्य फंक्शन के अंदर से बुलाया जा सकता है, बस फंक्शन का नाम लिखकर और आवश्यक पैरामीटर पास करके, यदि कोई हों (अनुभाग 7.3)। प्रोग्रामर कोड लिखते समय इच्छानुसार कई फंक्शन परिभाषित कर सकता है। प्रोग्राम $7-1$ को उपयोगकर्ता परिभाषित फंक्शन का उपयोग करके पुनः लिखा गया है जैसा कि प्रोग्राम 7-2 में दिखाया गया है।

प्रोग्राम 7-2 टेंट के लिए देय राशि की गणना करने के लिए प्रोग्राम उपयोगकर्ता परिभाषित फंक्शन का उपयोग करता है।

#प्रोग्राम 7-2
#टेंट की लागत की गणना करने के लिए प्रोग्राम
#फंक्शन परिभाषा
def cyl(h,r):
$\qquad$ area_cyl = 23.14r*h $\hspace{1.5cm}$ #बेलनाकार भाग का क्षेत्रफल
$\qquad$ return(area_cyl)

#फंक्शन परिभाषा
def con(l,r):
$\qquad$ area_con = 3.14rl $\hspace{1.5cm}$ #शंक्वाकार भाग का क्षेत्रफल
$\qquad$ return(area_con)

#फ़ंक्शन परिभाषा
def post_tax_price(cost): $\hspace{1.5cm}$ #टेंट के लिए देय राशि की गणना
$\qquad$ tax = 0.18 * cost;
$\qquad$ net_price = cost + tax
$\qquad$ return(net_price)

print(“टेंट के बेलनाकार भाग का मान मीटर में दर्ज करें:”)
h = float(input(“ऊँचाई: “))
r = float(input(“त्रिज्या: “))
csa_cyl = cyl(h,r) $\hspace{1.5cm}$ #फ़ंक्शन कॉल

l = float(input(“शंक्वाकार क्षेत्र की तिर्यक ऊँचाई मीटर में दर्ज करें: “))
csa_con = con(l,r) $\hspace{1.5cm}$ #फ़ंक्शन कॉल

#टेंट बनाने में प्रयोग होने वाले कैनवास का क्षेत्रफल गणना
canvas_area = csa_cyl + csa_con
print(“कैनवास का क्षेत्रफल = “,canvas_area,” m^2”)

#कैनवास की लागत गणना
unit_price = float(input(“1 m^2 कैनवास की लागत रुपयों में दर्ज करें: “))
total_cost = unit_price * canvas_area
print(“कर से पहले कैनवास की कुल लागत = “,total_cost)
print(“देय नेट राशि (कर सहित) = “,post_tax_price(total cost))_

यदि हम प्रोग्राम 7-1 और $7-2$ की तुलना करें, तो यह स्पष्ट है कि प्रोग्राम 7-2 अधिक संगठित और पढ़ने में आसान लगता है।

7.2.1 फ़ंक्शन के लाभ

मान लीजिए आगे चलकर कंपनी एक अन्य प्रकार का टेंट डिज़ाइन करने का निर्णय लेती है जिसका आधार आयताकार है, जबकि ऊपरी भाग वही रहता है। ऐसी स्थिति में मौजूदा कोड का कुछ भाग फ़ंक्शन con $(l, r)$ को कॉल करके पुन: उपयोग किया जा सकता है। यदि कंपनी अन्य उत्पाद विकसित करती है या सेवाएँ प्रदान करती है, और जहाँ $18 %$ कर दर लागू होनी है, प्रोग्रामर फ़ंक्शन post_tax_price(cost) को सीधे उपयोग कर सकता है।

इस प्रकार, किसी प्रोग्राम में फ़ंक्शनों का उपयोग करने के निम्नलिखित लाभ हैं:

• पठनीयता बढ़ाता है, विशेषकर लंबे कोड के लिए क्योंकि फ़ंक्शनों का उपयोग करने से प्रोग्राम बेहतर ढंग से संगठित होता है और समझने में आसान होता है।
• कोड की लंबाई घटाता है क्योंकि एक ही कोड को प्रोग्राम में कई जगहों पर लिखने की आवश्यकता नहीं होती। इससे डिबगिंग भी आसान हो जाती है।
• पुन: उपयोगिता बढ़ाता है, क्योंकि फ़ंक्शन को किसी अन्य फ़ंक्शन या किसी अन्य प्रोग्राम से बुलाया जा सकता है। इस प्रकार, हम पहले से परिभाषित फ़ंक्शनों का पुन: उपयोग कर सकते हैं या उन पर आगे निर्माण कर सकते हैं और एक ही कोड को बार-बार लिखने से बच सकते हैं।
• कार्य को आसानी से टीम के सदस्यों के बीच विभाजित किया जा सकता है और समानांतर में पूरा किया जा सकता है।

7.3 उपयोगकर्ता-परिभाषित फ़ंक्शन

फ़ंक्शनों की पुन: उपयोगिता विशेषता का लाभ उठाते हुए, Python में मानक लाइब्रेरी (अनुभाग 7.5) के अंतर्गत पहले से ही बड़ी संख्या में फ़ंक्शन उपलब्ध हैं। हम इन फ़ंक्शनों को अपने प्रोग्राम में परिभाषित किए बिना सीधे बुला सकते हैं। हालांकि, मानक लाइब्रेरी फ़ंक्शनों के अतिरिक्त, हम अपने प्रोग्राम लिखते समय अपने स्वयं के फ़ंक्शन भी परिभाषित कर सकते हैं। ऐसे फ़ंक्शनों को उपयोगकर्ता-परिभाषित फ़ंक्शन कहा जाता है। इस प्रकार, किसी कार्य को प्रोग्रामर की आवश्यकता के अनुसार प्राप्त करने के लिए परिभाषित किया गया फ़ंक्शन उपयोगकर्ता-परिभाषित फ़ंक्शन कहलाता है।

7.3.1 उपयोगकर्ता-परिभाषित फ़ंक्शन बनाना

किसी फ़ंक्शन की परिभाषा def (define का संक्षिप्त रूप) से शुरू होती है। उपयोगकर्ता-परिभाषित फ़ंक्शन बनाने के लिए वाक्य-रचना निम्नलिखित है:

• कोष्ठक “[ ]” में बंद वस्तुओं को पैरामीटर कहा जाता है और वे वैकल्पिक होते हैं। इसलिए, एक फंक्शन में पैरामीटर हो सकते हैं या नहीं भी। साथ ही, एक फंक्शन कोई मान लौटा सकता है या नहीं भी।
• फंक्शन हैडर हमेशा कोलन (:) से समाप्त होता है।
• फंक्शन का नाम अद्वितीय होना चाहिए। पहचानकर्ताओं के नामकरण के नियम फंक्शन नामकरण पर भी लागू होते हैं।
• फंक्शन इंडेंटेशन के बाहर लिखे गए कथन फंक्शन का हिस्सा नहीं माने जाते।

प्रोग्राम 7-3 दो संख्याओं को जोड़ने और उनके योग को प्रदर्शित करने के लिए एक उपयोगकर्ता-परिभाषित फंक्शन लिखें।

#प्रोग्राम 7-3
#दो संख्याओं को जोड़ने के लिए फंक्शन
#आवश्यकताएँ नीचे सूचीबद्ध हैं:
$\quad$ #1. हमें उपयोगकर्ता से 2 संख्याएँ स्वीकार करनी हैं।
$\quad$ #2. उनका योग गणना करें
$\quad$ #3. योग प्रदर्शित करें।

#फंक्शन परिभाषा
def addnum():
$\qquad$ fnum = int(input(“पहली संख्या दर्ज करें: “))
$\qquad$ snum = int(input(“दूसरी संख्या दर्ज करें: “))
$\qquad$ sum = fnum + snum
$\qquad$ print(“का योग “,fnum,“और “,snum,“है “,sum)

#फंक्शन कॉल
addnum()

फंक्शन addnum() को निष्पादित करने के लिए, हमें इसे कॉल करना होगा। प्रोग्राम में फंक्शन को उसके नाम के बाद कोष्ठक () लिखकर कॉल किया जा सकता है जैसा कि प्रोग्राम 7-3 की अंतिम पंक्ति में दिखाया गया है।

आउटपुट:

पहली संख्या दर्ज करें: 5
दूसरी संख्या दर्ज करें: 6
का योग 5 और 6 है 11

7.3.2 तर्क और पैरामीटर

उपरोक्त उदाहरण में, संख्याएँ उपयोगकर्ता से स्वयं फ़ंक्शन के भीतर स्वीकार की गईं, लेकिन यह भी संभव है कि उपयोगकर्ता-परिभाषित फ़ंक्शन कॉल होने के समय मान प्राप्त करे। एक तर्क (argument) वह मान होता है जो फ़ंक्शन कॉल के दौरान फ़ंक्शन को पास किया जाता है और जिसे फ़ंक्शन हेडर में परिभाषित संगत पैरामीटर द्वारा प्राप्त किया जाता है।

प्रोग्राम 7-4 एक उपयोगकर्ता-परिभाषित फ़ंक्शन का उपयोग करके एक प्रोग्राम लिखें जो पहले n प्राकृतिक संख्याओं का योग प्रदर्शित करता है, जहाँ n एक तर्क के रूप में पास किया जाता है।

#प्रोग्राम 7-4
#पहले n प्राकृतिक संख्याओं का योग ज्ञात करने के लिए प्रोग्राम
#आवश्यकताएँ हैं:
$\qquad$ #1. n को एक तर्क के रूप में पास किया जाए
$\qquad$ #2. पहले n प्राकृतिक संख्याओं का योग गणना करें
$\qquad$ #3. योग प्रदर्शित करें

#फ़ंक्शन हेडर
def sumSquares(n): $\qquad$ #n पैरामीटर है
$\quad$ sum = 0
$\quad$ for i in range(1,n+1):
$\qquad$ sum = sum + i
$\quad$ print(“The sum of first”,n,“natural numbers is: “,sum)

$\quad$ num = int(input(“Enter the value for n: “))
$\quad$ #num एक तर्क है जो उपयोगकर्ता द्वारा इनपुट किए गए मान को संदर्भित करता है
$\quad$ sumSquares(num) $\qquad$ #फ़ंक्शन कॉल

आकृति 7.3: तर्क और पैरामीटर दोनों एक ही मान को संदर्भित करते हैं

मान लीजिए कि प्रोग्राम $7-4$ के निष्पादन के दौरान उपयोगकर्ता ने 5 इनपुट किया। तो, num मान 5 को संदर्भित करता है। फिर इसे फंक्शन में तर्क के रूप में प्रयोग किया जाता है:

sumSquares (num)

चूँकि फंक्शन कॉल किया गया है, नियंत्रण फंक्शन को निष्पादित करने के लिए स्थानांतरित हो जाता है

def sumSquares (n):

जहाँ पैरामीटर $\mathrm{n}$ भी मान 5 को संदर्भित करता है जिसे num संदर्भित कर रहा है, जैसा कि चित्र 7.3 में दिखाया गया है।

चूँकि num और $\mathrm{n}$ दोनों एक ही मान को संदर्भित कर रहे हैं, उनकी पहचान एक ही होनी चाहिए। हम id() फंक्शन का उपयोग करके यह पता लगा सकते हैं कि तर्क और पैरामीटर किस वस्तु को संदर्भित कर रहे हैं। आइए इसे निम्नलिखित उदाहरण की सहायता से समझें। प्रोग्राम 7-5 एक उपयोगकर्ता-परिभाषित फंक्शन का उपयोग करके एक ऐसा प्रोग्राम लिखें जो एक पूर्णांक स्वीकार करता है और उसे 5 से बढ़ाता है। साथ ही तर्क की id (फंक्शन कॉल से पहले), पैरामीटर की id वृद्धि से पहले और वृद्धि के बाद प्रदर्शित करें।

प्रोग्राम 7-5 एक उपयोगकर्ता-परिभाषित फंक्शन का उपयोग करके एक ऐसा प्रोग्राम लिखें जो एक पूर्णांक स्वीकार करता है और उसे 5 से बढ़ाता है। साथ ही तर्क की id (फंक्शन कॉल से पहले), पैरामीटर की id वृद्धि से पहले और वृद्धि के बाद प्रदर्शित करें।

#प्रोग्राम 7-5
#उपयोगकर्ता द्वारा दी गई संख्या में 5 जोड़ने के लिए फ़ंक्शन
#आवश्यकताएँ नीचे दी गई हैं:
$\quad$ #1. फ़ंक्शन कॉल से पहले argument का id() दिखाएँ।
$\quad$ #2. फ़ंक्शन में argument स्वीकार करने के लिए एक पैरामीटर होना चाहिए
$\quad$ #3. पैरामीटर का मान और id() दिखाएँ।
$\quad$ #4. पैरामीटर में 5 जोड़ें
$\quad$ #5. पैरामीटर का नया मान और id() दिखाएँ ताकि यह जाँचा जा सके
$\qquad$ #कि पैरामीटर को कोई नया मेमोरी स्थान दिया गया है या
$\qquad$ #नहीं।
def incrValue(num):
$\qquad$ #वृद्धि से पहले Num का id
$\qquad$ print(“Parameter num has value:",num,"\nid =",id(num))
$\qquad$ num = num + 5
$\qquad$ #वृद्धि के बाद Num का id
$\qquad$ print(“num incremented by 5 is”,num,"\nNow id is “,id(num))
number = int(input(“Enter a number: “))
print(“id of argument number is:",id(number)) $\qquad$ #Number का id
incrValue(number)

आउटपुट:

Enter a number: 8
id of argument number is: 1712903328 $\qquad$ #number और num का id समान है
Parameter num has value: 8
id = 1712903328
num incremented by 5 is 13 $\qquad$ #Num का id बदल गया है।
Now id is 1712903408

आइए उपरोक्त आउटपुट को चित्र के माध्यम से समझें (देखें चित्र 7.4):

चित्र 7.4: वृद्धि से पहले और बाद तर्क और पैरामीटर की आईडी

तर्क और पैरामीटर दोनों का नाम एक समान हो सकता है जैसा कि प्रोग्राम 7-6 में दिखाया गया है।

प्रोग्राम 7-6 एक उपयोगकर्ता-परिभाषित फ़ंक्शन myMean() का उपयोग करते हुए एक सूची में संग्रहीत फ़्लोटिंग मानों का माध्य निकालने के लिए एक प्रोग्राम लिखें।

#प्रोग्राम 7-6
#माध्य निकालने के लिए फ़ंक्शन
#आवश्यकताएँ नीचे सूचीबद्ध हैं:
$\quad$ #1. फ़ंक्शन में 1 पैरामीटर होना चाहिए (फ़्लोटिंग मानों वाली सूची)
$\qquad$ #2. सभी संख्याओं को जोड़कर और कुल तत्वों की संख्या से
$\qquad$ #भाग देकर माध्य निकालना

def myMean(myList): #सूची में मानों का माध्य निकालने के लिए फ़ंक्शन
$\quad$ total = 0
$\quad$ count = 0
$\quad$ for i in myList:
$\qquad$ total = total + i $\qquad$ #प्रत्येक तत्व i को total में जोड़ता है
$\qquad$ count = count + 1 $\qquad$ #तत्वों की संख्या गिनता है
$\quad$ mean = total/count $\qquad$ #माध्य की गणना की जाती है
$\quad$ print(“The calculated mean is:",mean)
myList = [1.3,2.4,3.5,6.9]
#फ़ंक्शन कॉल जिसमें “myList” सूची को तर्क के रूप में दिया गया है
myMean(myList)

आउटपुट:

The calculated mean is: 3.5250000000000004

प्रोग्राम 7-7 एक उपयोगकर्ता-परिभाषित फ़ंक्शन calcFact() का उपयोग करते हुए एक प्रोग्राम लिखें जो तर्क के रूप में पास की गई संख्या num का फैक्टोरियल निकालकर प्रदर्शित करे।

#प्रोग्राम 7-7
#फंक्शन फैक्टोरियल गणना करने के लिए
#आवश्यकताएँ नीचे सूचीबद्ध हैं:
$\quad$ #1. फंक्शन को उपयोगकर्ता से एक पूर्णांक तर्क स्वीकार करना चाहिए।
$\quad$ #2. फैक्टोरियल की गणना करें। उदाहरण के लिए:
$\quad$ #3. फैक्टोरियल प्रदर्शित करें
def calcFact(num):
$\quad$ fact = 1
$\quad$ for i in range(num,0,-1):
$\qquad$ fact = fact * i
$\quad$ print(“Factorial of”,num,“is”,fact)

num = int(input(“Enter the number: “))
calcFact(num)

आउटपुट:

Enter the number: 5
Factorial of 5 is 120

नोट: चूँकि गुणा क्रमविनिमय है 5! = 5 * 4 * 3 * 2 * 1 = 1 * 2 * 3 * 4 * 5

(A) स्ट्रिंग को पैरामीटर के रूप में

प्रोग्राम $7-5$ से $7-7$ में, पास किए गए तर्क केवल संख्यात्मक प्रकार के हैं। हालाँकि, कुछ प्रोग्रामों में उपयोगकर्ता को स्ट्रिंग मानों को तर्क के रूप में पास करने की आवश्यकता हो सकती है, जैसा कि प्रोग्राम 7-8 में दिखाया गया है।

प्रोग्राम 7-8 एक प्रोग्राम लिखें जो एक यूज़र-डिफ़ाइंड फंक्शन का उपयोग करता है जो पहला नाम और अंतिम नाम को तर्क के रूप में स्वीकार करता है, उन्हें जोड़कर पूरा नाम बनाता है और आउटपुट इस प्रकार प्रदर्शित करता है:

Hello full name

उदाहरण के लिए, यदि पहला नाम Gyan है और अंतिम नाम Vardhan है, तो आउटपुट होना चाहिए:

Hello Gyan Vardhan

#कार्यक्रम 7-8
#पूरा नाम प्रदर्शित करने के लिए फ़ंक्शन
#आवश्यकताएँ नीचे दी गई हैं:
$\quad$ #1. फ़ंक्शन में 2 पैरामीटर होने चाहिए जो पहला नाम और
$\qquad$ #अंतिम नाम स्वीकार कर सकें।
$\quad$ #2. पहले नाम और अंतिम नाम के बीच एक रिक्त स्थान के साथ + ऑपरेटर का उपयोग करके नामों को जोड़ना।
$\qquad$ #
$\quad$ #3. पूरा नाम प्रदर्शित करें।
def fullname(first,last):
#+ ऑपरेटर का उपयोग स्ट्रिंग्स को जोड़ने के लिए किया जाता है
$\quad$ fullname = first + " " + last
$\quad$ print(“Hello”,fullname)
#फ़ंक्शन यहाँ समाप्त होता है
first = input(“Enter first name: “)
last = input(“Enter last name: “)
#फ़ंक्शन कॉल
fullname(first,last)

आउटपुट:

Enter first name: Gyan
Enter last name: Vardhan
Hello Gyan Vardhan

(B) डिफ़ॉल्ट पैरामीटर

Python पैरामीटर को एक डिफ़ॉल्ट मान निर्धारित करने की अनुमति देता है। डिफ़ॉल्ट मान एक पूर्वनिर्धारित मान होता है जो फ़ंक्शन कॉल में उससे संगत तर्क नहीं होने पर पैरामीटर को सौंपा जाता है।

कार्यक्रम 7-9 एक ऐसा कार्यक्रम लिखें जो एक भिन्न संख्या के अंश और हर को स्वीकार करे और जब बनाई गई भिन्न एक उचित भिन्न न हो तो एक उपयोगकर्ता-परिभाषित फ़ंक्शन mixedFraction() को कॉल करे। हर का डिफ़ॉल्ट मान 1 है। फ़ंक्शन केवल तभी एक मिश्रित भिन्न प्रदर्शित करता है जब पैरामीटरों द्वारा बनाई गई भिन्न एक पूर्ण संख्या में परिवर्तित नहीं होती।

#प्रोग्राम 7-9
#एक अनुचित भिन्न के लिए मिश्रित भिन्न प्रदर्शित करने के लिए फ़ंक्शन
#आवश्यकताएँ नीचे सूचीबद्ध हैं:
$\quad$ #1. उपयोगकर्ता से अंश और हर इनपुट करें।
$\quad$ #2. जाँच करें कि दर्ज किया गया अंश और हर एक उचित भिन्न बनाते हैं या नहीं।
$\qquad$ #भिन्न।
$\quad$ #3. यदि वे एक उचित भिन्न नहीं बनाते हैं, तो
$\quad$ #mixedFraction() को कॉल करें।
$\quad$ #4. mixedFraction() एक मिश्रित भिन्न तभी प्रदर्शित करता है जब भिन्न
$\qquad$ #एक पूर्ण संख्या के रूप में व्यक्त न हो।

def mixedFraction(num,deno = 1):
$\quad$ remainder = num % deno
#जाँचें कि भिन्न एक पूर्ण संख्या के रूप में व्यक्त नहीं होता है
$\quad$ if remainder!= 0:
$\qquad$ quotient = int(num/deno)
$\qquad$ print(“The mixed fraction=”, quotient,”(",remainder, “/”, \ deno,”)”)
$\quad$ else:
$\qquad$ print(“The given fraction evaluates to a whole number”)
#फ़ंक्शन यहाँ समाप्त होता है
num = int(input(“Enter the numerator: “))
deno = int(input(“Enter the denominator: “))
print(“You entered:",num,”/",deno)
if num > deno: $\qquad$ #यह शर्त जाँचती है कि भिन्न अनुचित है या नहीं
mixedFraction(num,deno) $\qquad$ #फ़ंक्शन कॉल
else:
print(“It is a proper fraction”)

आउटपुट:

Enter the numerator: 17
Enter the denominator: 2
You entered: 17 / 2
The mixed fraction = 8 (1 / 2)

उपरोक्त प्रोग्राम में, दर्ज किया गया हर 2 है, जो पैरामीटर “deno” को पास किया जाता है, इसलिए आर्ग्यूमेंट deno का डिफ़ॉल्ट मान अधिलेखित हो जाता है।

आइए निम्नलिखित फ़ंक्शन कॉल पर विचार करें:

mixedFraction (9)

यहाँ, num को 9 असाइन किया जाएगा और deno डिफ़ॉल्ट मान 1 का उपयोग करेगा।

नोट:

• एक फ़ंक्शन आर्गुमेंट एक एक्सप्रेशन भी हो सकता है, जैसे

mixedFraction (num +5 , deno+5)

ऐसे मामले में, फ़ंक्शन को कॉल करने से पहले आर्गुमेंट का मूल्यांकन किया जाता है ताकि पैरामीटर को एक वैध मान असाइन किया जा सके।

• पैरामीटर्स को आर्गुमेंट्स के समान क्रम में होना चाहिए।

डिफ़ॉल्ट पैरामीटर्स फ़ंक्शन हेडर में अंतिम पैरामीटर्स होने चाहिए, इसका अर्थ है कि यदि किसी पैरामीटर का डिफ़ॉल्ट मान है तो उसके दाईं ओर के सभी अन्य पैरामीटर्स का भी डिफ़ॉल्ट मान होना चाहिए। उदाहरण के लिए,

def mixedFraction(num,deno = 1)
def mixedFraction(num = 2,deno = 1)

आइए कुछ और फ़ंक्शन डेफिनिशन हेडर्स पर विचार करें:

#incorrect as default must be the last
#parameter
def calcInterest(principal = 1000, rate, time = 5):
#correct
def calcInterest(rate,principal = 1000, time = 5):

7.3.3 मान लौटाने वाले फ़ंक्शन्स

एक फ़ंक्शन जब कॉल किया जाता है तो मान लौटा सकता है या नहीं भी। return स्टेटमेंट फ़ंक्शन से मान लौटाता है। अब तक दिए गए उदाहरणों में, फ़ंक्शन गणना करता है और परिणाम प्रदर्शित करता है। वे कोई मान लौटाते नहीं हैं। ऐसे फ़ंक्शन्स को void फ़ंक्शन्स कहा जाता है। लेकिन एक स्थिति उत्पन्न हो सकती है, जब हमें फ़ंक्शन से कॉलिंग फ़ंक्शन में मान भेजने की आवश्यकता हो। यह return स्टेटमेंट का उपयोग करके किया जाता है।

return स्टेटमेंट निम्नलिखित कार्य करता है:

• नियंत्रण को कॉलिंग फंक्शन को वापस लौटाता है।
• रिटर्न वैल्यू(ज़) या None।

प्रोग्राम 7-10 एक ऐसा प्रोग्राम लिखिए जो यूज़र-डिफ़ाइंड फंक्शन calcPow() का इस्तेमाल करे, जो बेस और एक्सपोनेंट को आर्गुमेंट्स के रूप में स्वीकार करता है और $Base^{exponent}$ का मान लौटाता है, जहाँ Base और exponent पूर्णांक हैं।

#प्रोग्राम 7-10
#फंक्शन बेस को एक्सपोनेंट की घात पर चढ़ाकर परिणाम निकालने और दिखाने के लिए
#नीचे आवश्यकताएँ दी गई हैं:
$\quad$ #1. बेस और एक्सपोनेंट को आर्गुमेंट्स के रूप में स्वीकार करना है।
$\quad$ #2. Baseexponent की गणना करना
$\quad$ #3. परिणाम लौटाना (return स्टेटमेंट का प्रयोग करें)
$\quad$ #4. लौटाया गया मान प्रदर्शित करना।
def calcpow(number,power): $\quad$ #फंक्शन परिभाषा
$\quad$ result = 1
$\quad$ for i in range(1,power+1):
$\qquad$ result = result * number
$\quad$ return result

base = int(input(“बेस का मान दर्ज करें: “))
expo = int(input(“एक्सपोनेंट का मान दर्ज करें: “))
answer = calcpow(base,expo) $\quad$ #फंक्शन कॉल
print(base,“का घात”,expo,“परिणाम”,answer,“है”)

आउटपुट:

बेस का मान दर्ज करें: 5
एक्सपोनेंट का मान दर्ज करें: 4
5 का घात 4 परिणाम 625 है

अब तक हमने सीखा है कि एक फंक्शन के पास पैरामीटर(हो) सकते हैं या नहीं भी, और एक फंक्शन कोई मान लौटा सकता है या नहीं भी। Python में, हमारी आवश्यकताओं के अनुसार, हम निम्नलिखित किसी भी तरीके से फंक्शन बना सकते हैं:

• कोई आर्ग्युमेंट नहीं और कोई रिटर्न वैल्यू नहीं वाला फ़ंक्शन
• कोई आर्ग्युमेंट नहीं लेकिन रिटर्न वैल्यू(ज़) वाला फ़ंक्शन
• आर्ग्युमेंट(ज़) लेकिन कोई रिटर्न वैल्यू नहीं वाला फ़ंक्शन
• आर्ग्युमेंट(ज़) और रिटर्न वैल्यू(ज़) दोनों वाला फ़ंक्शन

7.3.4 निष्पादन का प्रवाह

निष्पादन का प्रवाह उस क्रम को कहा जा सकता है जिसमें प्रोग्राम में मौजूद कथनों को निष्पादित किया जाता है। पायथन इंटरप्रेटर प्रोग्राम के पहले कथन से शुरुआत करके निर्देशों को निष्पादित करता है। कथन एक-एक करके, ऊपर से नीचे आने वाले क्रम में निष्पादित होते हैं।

जब इंटरप्रेटर किसी फ़ंक्शन परिभाषना से टकराता है, तब फ़ंक्शन के अंदर के कथन तब तक निष्पादित नहीं होते जब तक वह फ़ंक्शन कॉल नहीं किया जाता। बाद में जब इंटरप्रेटर किसी फ़ंक्शन कॉल से टकराता है, तो निष्पादन के प्रवाह में थोड़ा विचलन होता है। उस स्थिति में अगले कथन पर जाने के बजाय नियंत्रण कॉल किए गए फ़ंक्शन पर कूद जाता है और उस फ़ंक्शन के कथनों को निष्पादित करता है। उसके बाद नियंत्रण फ़ंक्शन कॉल के बिंदु पर वापस आता है ताकि प्रोग्राम में बचे हुए कथनों को निष्पादित किया जा सके। इसलिए जब हम कोई प्रोग्राम पढ़ते हैं, तो हमें केवल ऊपर से नीचे नहीं पढ़ना चाहिए। इसके बजाय हमें नियंत्रण या निष्पादन के प्रवाह का अनुसरण करना चाहिए। यह भी ध्यान रखना महत्वपूर्ण है कि किसी फ़ंक्शन को उसके कॉल से पहले परिभाषित किया जाना चाहिए।

प्रोग्राम 7-11 निष्पादन के प्रवाह को फ़ंक्शन का उपयोग करके समझने के लिए प्रोग्राम।

#प्रोग्राम 7-11
#फ़ंक्शन का उपयोग करके प्रिंट करना
helloPython() $\qquad$ #फ़ंक्शन कॉल

def helloPython(): $\qquad$ #Function definition
$\quad$ print(“I love Programming”)

उपरोक्त कोड को चलाने पर निम्नलिखित त्रुटि उत्पन्न होती है:

Traceback (most recent call last):
$\quad$ File “C:\NCERT\Prog 7-11.py”, line 3, in
$\qquad$ helloPython() #Function Call
NameError: name ‘helloPython’ is not defined

त्रुटि ‘function not defined’ तब भी उत्पन्न होती है जब फंक्शन को परिभाषित किया गया है। जब एक फंक्शन कॉल मिलता है, तो नियंत्रण को फंक्शन परिभाषा पर कूदना होता है और उसे निष्पादित करना होता है। उपरोक्त प्रोग्राम में, चूँकि फंक्शन कॉल फंक्शन परिभाषा से पहले आता है, इंटरप्रेटर फंक्शन परिभाषा नहीं ढूँढ पाता और इसलिए एक त्रुटि उत्पन्न होती है।

इसीलिए, फंक्शन परिभाषा को फंक्शन कॉल से पहले बनाया जाना चाहिए जैसा कि नीचे दिखाया गया है:

def hellopython(): #Function definition
$\quad$ print(“I love Programming”)

आकृति 7.5: कथनों के निष्पादन का क्रम

आकृति 7.5 दो प्रोग्रामों के लिए निष्पादन के प्रवाह को समझाती है। वर्ग कोष्ठक में दिखाई गई संख्या कथनों के निष्पादन का क्रम दर्शाती है।
कभी-कभी, एक फंक्शन को एक से अधिक मान वापस करने की आवश्यकता होती है जो टपल का उपयोग करके वापस किए जा सकते हैं। प्रोग्राम 7-12 एक ऐसा फंक्शन दिखाता है जो आयत के दो मान क्षेत्रफल और परिमाप टपल का उपयोग करके वापस करता है।

प्रोग्राम 7-12 एक उपयोगकर्ता-परिभाषित फ़ंक्शन का उपयोग करते हुए एक प्रोग्राम लिखें जो आयत की लंबाई और चौड़ाई स्वीकार करता है और आयत का क्षेत्रफल और परिमाप लौटाता है।

#प्रोग्राम 7-12
#आयत का क्षेत्रफल और परिमाप गणना करने के लिए फ़ंक्शन
#आवश्यकताएँ नीचे सूचीबद्ध हैं:
$\quad$ #1. फ़ंक्शन को 2 पैरामीटर स्वीकार करने चाहिए।
$\quad$ #2. क्षेत्रफल और परिमाप की गणना करें।
$\quad$ #3. क्षेत्रफल और परिमाप लौटाएं।

def calcAreaPeri(Length,Breadth):
$\qquad$ area = length * breadth
$\qquad$ perimeter =2 * (length + breadth )
$\qquad$ #एक टपल लौटाया जाता है जिसमें 2 मान क्षेत्रफल और परिमाप होते हैं return (area, perimeter)

$1=$ float (input (“आयत की लंबाई दर्ज करें: “))
b = float (input (“आयत की चौड़ाई दर्ज करें: “))
#टपल के मान उसी क्रम में निर्धारित किए जाते हैं जिसमें वे लौटाए जाते हैं
area, perimeter $=$ calcAreaPeri $(1, b)$
print(“क्षेत्रफल है:”, area,"\nपरिमाप है:”, perimeter)

आउटपुट:

आयत की लंबाई दर्ज करें: 45
आयत की चौड़ाई दर्ज करें: 66
क्षेत्रफल है: 2970.0
परिमाप है: 222.0

प्रोग्राम 7-13 एक प्रोग्राम लिखें जो एक ट्रैफ़िक लाइट का अनुकरण करता है। प्रोग्राम में निम्नलिखित होना चाहिए:

1. एक उपयोगकर्ता-परिभाषित फ़ंक्शन trafficLight( ) जो उपयोगकर्ता से इनपुट स्वीकार करता है, यदि उपयोगकर्ता RED, YELLOW और GREEN के अलावा कुछ और दर्ज करता है तो त्रुटि संदेश प्रदर्शित करता है। फ़ंक्शन light() को बुलाया जाता है और light() से लौटाए गए मान के आधार पर निम्नलिखित प्रदर्शित किया जाता है।

a) “रुकें, आपकी जीवन अनमोल है” यदि light() द्वारा लौटाया गया मान 0 है।

b) “कृपया प्रतीक्षा करें, जब तक बत्ती हरी नहीं हो जाती” यदि light() द्वारा लौटाया गया मान 1 है

c) “चलें! धैर्य रखने के लिए धन्यवाद” यदि light() द्वारा लौटाया गया मान 2 है।

2. एक उपयोगकर्ता-परिभाषित फ़ंक्शन light() जो इनपुट के रूप में एक स्ट्रिंग स्वीकार करता है और इनपुट RED होने पर 0, YELLOW होने पर 1 और GREEN होने पर 2 लौटाता है। इनपुट को तर्क के रूप में पास किया जाना चाहिए।

3. फ़ंक्शन trafficLight() निष्पादित होने के बाद “SPEED THRILLS BUT KILLS” प्रदर्शित करें।

#Program 7-13
#Function to simulate a traffic light
#It is required to make 2 user defined functions trafficLight() and
#light().

def trafficLight():
$\quad$ signal = input(“Enter the colour of the traffic light: “)
$\quad$ if (signal not in (“RED”,“YELLOW”,“GREEN”)):
$\qquad$ print(“Please enter a valid Traffic Light colour in CAPITALS”)
$\quad$ else:
$\quad$ value = light(signal) $\qquad$ #function call to light()
$\quad$ if (value == 0):
$\qquad$ print(“STOP, Your Life is Precious.”)
$\quad$ elif (value == 1):
$\qquad$ print (“PLEASE GO SLOW.”)
$\quad$ else:
$\qquad$ print(“GO!,Thank you for being patient.”)
#function ends here

def light(colour):
$\quad$ if (colour == “RED”):
$\qquad$ return(0);
$\quad$ elif (colour == “YELLOW”):
$\qquad$ return (1)
$\quad$ else:
$\qquad$ return(2)
#function ends here

trafficLight() print(“SPEED THRILLS BUT KILLS”)

Output:

यातायात बत्ती का रंग दर्ज करें: पीला
कृपया धीरे चलें।
रफ्तार रोमांचक लेकिन घातक होती है

7.4 चर का स्कोप

एक फ़ंक्शन के अंदर परिभाषित चर को उसके बाहर एक्सेस नहीं किया जा सकता। हर चर की एक स्पष्ट पहुँच होती है। प्रोग्राम का वह भाग जहाँ एक चर एक्सेसिबल हो, उसे उस चर का स्कोप कहा जा सकता है। एक चर निम्नलिखित दो स्कोप्स में से कोई एक हो सकता है:

एक चर जिसका ग्लोबल स्कोप होता है, उसे ग्लोबल वेरिएबल कहा जाता है और एक चर जिसका लोकल स्कोप होता है, उसे लोकल वेरिएबल कहा जाता है।

चित्र 7.6: चर का स्कोप

(A) ग्लोबल वेरिएबल

पायथन में, कोई चर जो किसी फ़ंक्शन या किसी ब्लॉक के बाहर परिभाषित होता है, उसे ग्लोबल वेरिएबल कहा जाता है। इसे आगे आने वाले किसी भी फ़ंक्शन में एक्सेस किया जा सकता है। ग्लोबल वेरिएबल में किया गया कोई भी बदलाव प्रोग्राम के उन सभी फ़ंक्शनों पर असर डालेगा जहाँ वह चर एक्सेसिबल है।

(B) लोकल वेरिएबल

कोई चर जो किसी फ़ंक्शन या किसी ब्लॉक के अंदर परिभाषित होता है, उसे लोकल वेरिएबल कहा जाता है। इसे केवल उसी फ़ंक्शन या ब्लॉक में एक्सेस किया जा सकता है जहाँ यह परिभाषित है। यह तब तक ही मौजूद रहता है जब तक फ़ंक्शन चलता है।

प्रोग्राम 7-14 फ़ंक्शन के बाहर किसी चर को एक्सेस करने का प्रोग्राम

#कार्यक्रम 7-14
#फंक्शन के बाहर किसी भी वेरिएबल तक पहुँचने के लिए
num = 5
def myFunc1( ):
$\quad$ y = num + 5
$\quad$ print(“Accessing num -> (global) in myFunc1, value = “,num)
$\quad$ print(“Accessing y-> (local variable of myFunc1) accessible, value=",y)

myFunc1()
print(“Accessing num outside myFunc1 “,num)
print(“Accessing y outside myFunc1 “,y)

आउटपुट:

Accessing num -> (global) in myFunc1, value = 5
Accessing y-> (local variable of myFunc1) accessible, value = 10
Accessing num outside myFunc1 5
Traceback (most recent call last):
$\quad$ File “C:\NCERT\Prog 7-14.py”, line 9, in
$\qquad$ print(“Accessing y outside myFunc1 “,y) $\longrightarrow$ y generates error when it is accessed outside myfunc1()
NameError: name ‘y’ is not defined

$\longrightarrow$ lobal variable output, $\longrightarrow$ Local variable output

नोट:

• ग्लोबल वेरिएबल में कोई भी संशोधन स्थायी होता है और उन सभी फंक्शनों को प्रभावित करता है जहाँ इसका उपयोग होता है।
• यदि किसी फंक्शन के अंदर ग्लोबल वेरिएबल के समान नाम का वेरिएबल परिभाषित किया जाता है, तो वह उस फंक्शन के लिए स्थानीय माना जाता है और ग्लोबल वेरिएबल को छिपा देता है।
• यदि ग्लोबल वेरिएबल का संशोधित मान फंक्शन के बाहर उपयोग करना है, तो फंक्शन में वेरिएबल के नाम से पहले कीवर्ड global लगाना आवश्यक है।

कार्यक्रम 7-15 फंक्शन के बाहर किसी भी वेरिएबल तक पहुँचने के लिए एक कार्यक्रम लिखें।

#कार्यक्रम 7-15
#फंक्शन के बाहर किसी भी वेरिएबल तक पहुँचने के लिए

num = 5
def myfunc1():
$\quad$ #वैश्विक चर num को अद्यतन करने के लिए Python को बताने के लिए global उपसर्ग
$\quad$ #फ़ंक्शन के बाहर वैश्विक चर num का उपयोग करें
$\quad$ global num
$\quad$ print(“Accessing num =",num)
$\quad$ num = 10
$\quad$ print(“num reassigned =",num)
#यहाँ फ़ंक्शन समाप्त होता है

myfunc1()
print(“Accessing num outside myfunc1”,num)

आउटपुट:

Accessing num = 5 $\longleftarrow$ वैश्विक चर num तक पहुँचा गया क्योंकि global उपसर्ग द्वारा अस्पष्टता दूर हो गई
num reassigned = 10
Accessing num outside myfunc1 10

7.5 PYTHON STANDARD LIBRARY

Python का एक बहुत विस्तृत मानक पुस्तकालय है। यह कई अंतर्निहित फ़ंक्शनों का संग्रह है जिन्हें कार्यक्रम में आवश्यकतानुसार बुलाया जा सकता है, इस प्रकार प्रोग्रामर का समय बचता है जो हर बार इन सामान्यतः प्रयुक्त फ़ंक्शनों को बनाने में लगता।

आकृति 7.7: फ़ंक्शनों के प्रकार

7.5.1 अंतर्निहित फ़ंक्शन

अंतर्निहित फ़ंक्शन Python में तैयार-मेड फ़ंक्शन होते हैं जो प्रोग्राम में बार-बार उपयोग किए जाते हैं। आइए निम्नलिखित Python प्रोग्राम को देखें:

#एक संख्या का वर्ग निकालने के लिए प्रोग्राम
a = int(input(“Enter a number: “)
b = a * a
print(” The square of “,a ,“is”, b)

उपरोक्त प्रोग्राम में input(), int() और print() बिल्ट-इन फ़ंक्शन हैं। इन बिल्ट-इन फ़ंक्शनों के लिए निष्पादित होने वाले निर्देशों का समूह पहले से ही Python इंटरप्रेटर में परिभाषित है।

आइए निम्नलिखित Python कथन पर विचार करें जिसमें एक बिल्ट-इन फ़ंक्शन को कॉल किया गया है और दिए गए प्रश्नों के उत्तर दें:

fname = input(“Enter your name: “)

किस फ़ंक्शन का नाम प्रयोग किया जा रहा है?

- input()

क्या फ़ंक्शन कोई मान या आर्ग्युमेंट स्वीकार करता है?

• हाँ, क्योंकि कोष्ठक “()” में स्ट्रिंग “Enter your name” है।

क्या फ़ंक्शन कोई मान लौटाता है?

• हाँ, चूँकि फ़ंक्शन के नाम से पहले असाइनमेंट (=) ऑपरेटर है, इसका अर्थ है कि फ़ंक्शन एक मान लौटाता है जो चर fname में संग्रहीत होता है।

इस प्रकार, फ़ंक्शन input() एक मान स्वीकार करता है और एक मान लौटाता है।

अब बिल्ट-इन फ़ंक्शन int() और print() पर विचार करें और नीचे दिए गए प्रश्नों के उत्तर दें:

• क्या फ़ंक्शन कोई मान या आर्ग्युमेंट स्वीकार करता है?
• क्या फ़ंक्शन कोई मान लौटाता है?

निम्नलिखित Python में प्रायः प्रयोग किए जाने वाले कुछ बिल्ट-इन फ़ंक्शनों की वर्गीकृत सूची है:

हम पहले से ही कुछ बिल्ट-इन फ़ंक्शनों का प्रयोग कर चुके हैं। आइए उनमें से कुछ से तालिका 7.1 में दिए गए विवरण के अनुसार परिचित हों।

$\hspace{5cm}$ तालिका 7.1 सामान्यतः प्रयुक्त बिल्ट-इन फ़ंक्शन

7.5.2 मॉड्यूल

इन-बिल्ट फ़ंक्शनों के अलावा, Python standard library में कई मॉड्यूल भी होते हैं। जहाँ एक फ़ंक्शन निर्देशों का समूह होता है, वहीं एक मॉड्यूल फ़ंक्शनों का समूह होता है। जैसा कि हम जानते हैं कि जब कोई प्रोग्राम बढ़ता है, तो कोड को सरल बनाने और दोहराव से बचने के लिए फ़ंक्शन का उपयोग किया जाता है। किसी जटिल समस्या के लिए, कोड को एक ही फ़ाइल में प्रबंधित करना संभव नहीं हो सकता। तब प्रोग्राम को विभिन्न स्तरों के तहत विभिन्न भागों में बाँटा जाता है, जिन्हें मॉड्यूल कहा जाता है। साथ ही, मान लीजिए हमने किसी प्रोग्राम में कुछ फ़ंक्शन बनाए हैं और हम उन्हें किसी अन्य प्रोग्राम में पुन: उपयोग करना चाहते हैं। उस स्थिति में, हम उन फ़ंक्शनों को एक मॉड्यूल के तहत सहेज सकते हैं और उन्हें पुन: उपयोग कर सकते हैं। एक मॉड्यूल एक Python (.py) फ़ाइल के रूप में बनाया जाता है जिसमें फ़ंक्शन परिभाषाओं का संग्रह होता है।

किसी मॉड्यूल का उपयोग करने के लिए, हमें उस मॉड्यूल को आयात (import) करना होता है। एक बार जब हम कोई मॉड्यूल आयात कर लेते हैं, तो हम उस मॉड्यूल के सभी फ़ंक्शनों को सीधे उपयोग कर सकते हैं। import statement का syntax इस प्रकार है:

import modulename1 [, modulename2, …]

यह हमें मॉड्यूल(स) में मौजूद सभी फ़ंक्शनों तक पहुँच देता है। किसी मॉड्यूल के फ़ंक्शन को बुलाने के लिए, फ़ंक्शन नाम से पहले मॉड्यूल का नाम एक $\operatorname{dot}($.$) separator के साथ लिखा जाता है।$

Syntax इस प्रकार है:

modulename.functionname()

(A) Built-in Modules

Python library में कई built-in मॉड्यूल होते हैं जो प्रोग्रामरों के लिए बहुत उपयोगी होते हैं। आइए कुछ सामान्यतः उपयोग किए जाने वाले मॉड्यूल्स और उन मॉड्यूल्स में पाए जाने वाले प्रायः उपयोग किए जाने वाले फ़ंक्शनों का अन्वेषण करें:

• math
• random
• statistics

याद रखें, Python केस-संवेदी है। सभी मॉड्यूल नाम छोटे अक्षरों में होते हैं।

1. मॉड्यूल नाम : math

इसमें विभिन्न प्रकार की गणितीय फ़ंक्शनें होती हैं। इस मॉड्यूल में अधिकांश फ़ंक्शन फ़्लोट मान लौटाते हैं। math मॉड्यूल में प्रयुक्त कुछ सामान्य फ़ंक्शन टेबल 7.2 में दिए गए हैं। math मॉड्यूल का उपयोग करने के लिए हमें निम्नलिखित कथन का उपयोग करके इसे आयात करना होगा:

import math

$\hspace{3cm}$ टेबल 7.2 math मॉड्यूल में प्रयुक्त सामान्य फ़ंक्शन

2. मॉड्यूल का नाम : random

इस मॉड्यूल में फ़ंक्शन होते हैं जो यादृच्छिक संख्याएँ उत्पन्न करने के लिए उपयोग किए जाते हैं। random मॉड्यूल में कुछ सामान्यतः प्रयुक्त फ़ंक्शन टेबल 7.3 में दिए गए हैं। इस मॉड्यूल का उपयोग करने के लिए, हम इसे निम्नलिखित कथन का उपयोग करके आयात कर सकते हैं:

import random

$\hspace{3cm}$ टेबल 7.3 random मॉड्यूल में सामान्यतः प्रयुक्त फ़ंक्शन

3. मॉड्यूल का नाम : statistics

यह मॉड्यूल संख्यात्मक (वास्तविक-मान) डेटा के सांख्यिकी की गणना करने के लिए फ़ंक्शन प्रदान करता है। सांख्यिकी मॉड्यूल में प्रयुक्त कुछ सामान्य फ़ंक्शन टेबल 7.4 में दिए गए हैं। इसे कार्यक्रम में निम्नलिखित कथनों द्वारा सम्मिलित किया जा सकता है:

import statistics

$\hspace{0.5cm}$ टेबल 7.4 statistics मॉड्यूल के माध्यम से उपलब्ध कुछ फ़ंक्शन

नोट:

• import कथन कार्यक्रम में कहीं भी लिखा जा सकता है
• मॉड्यूल को केवल एक बार आयात करना चाहिए
• Python में उपलब्ध मॉड्यूलों की सूची प्राप्त करने के लिए हम निम्नलिखित कथन का उपयोग कर सकते हैं:

$\hspace{1cm}$ >>> help(“module”)

• किसी मॉड्यूल, मान लीजिए math, की सामग्री देखने के लिए निम्नलिखित टाइप करें:

$\hspace{1cm}$ >>>help(“math”)

चित्र 7.8: मॉड्यूल “math” की सामग्री

• Python के Lib फ़ोल्डर में स्टैंडर्ड लाइब्रेरी के मॉड्यूल मिल सकते हैं।

(B) From Statement

किसी मॉड्यूल को इम्पोर्ट करके सारे फ़ंक्शन्स मेमोरी में लोड करने के बजाय, from स्टेटमेंट का इस्तेमाल करके केवल ज़रूरी फ़ंक्शन्स को ही एक्सेस किया जा सकता है। यह मॉड्यूल के सभी फ़ंक्शन्स के बजाय केवल निर्दिष्ट फ़ंक्शन(स) को ही लोड करता है।

अच्छा प्रोग्रामिंग अभ्यास: केवल ज़रूरी फ़ंक्शन(स) का इस्तेमाल करना, पूरे मॉड्यूल को इम्पोर्ट करने की तुलना में मेमोरी बचाता है।

इसका सिंटैक्स है

>>> from modulename import functionname [, functionname, …]

“from statement” का इस्तेमाल करके जब फ़ंक्शन इम्पोर्ट किया जाता है, तो उसे इस्तेमाल करने के लिए मॉड्यूल का नाम आगे लगाने की ज़रूरत नहीं होती। बल्कि हम सीधे फ़ंक्शन को इस तरह कॉल कर सकते हैं जैसा कि निम्न उदाहरणों में दिखाया गया है:

उदाहरण 7.5

>>> from random import random
>>> random() $\quad$ #Function called without the module name

आउटपुट:

0.9796352504608387

उदाहरण 7.6

>>> from math import ceil,sqrt
>>> value = ceil(624.7)
>>> sqrt(value)

आउटपुट:

25.0

उदाहरण 7.2 में, 624.7 का ceil मान वेरिएबल “value” में स्टोर किया गया है और फिर sqrt फ़ंक्शन को वेरिएबल “value” पर अप्लाई किया गया है। उपरोक्त उदाहरण को इस तरह भी लिखा जा सकता है:

>>> sqrt (ceil (624.7))

फ़ंक्शन sqrt () का एक्ज़िक्यूशन ceil( ) फ़ंक्शन के आउटपुट पर निर्भर करता है।

अगर हमें 624.7 का इंटीजर पार्ट निकालना है (हम math मॉड्यूल से trunc( ) फ़ंक्शन का इस्तेमाल करेंगे), तो हम निम्न स्टेटमेंट्स का इस्तेमाल कर सकते हैं।

#ceil और sqrt पहले ही ऊपर import किए जा चुके हैं
>>> from math import trunc
>>> sqrt(trunc(625.7))

आउटपुट:

25.0

एक प्रोग्रामिंग स्टेटमेंट जिसमें फंक्शन या एक्सप्रेशन एक-दूसरे के आउटपुट को प्राप्त करने के लिए एक-दूसरे के निष्पादन पर निर्भर हों, उसे कम्पोज़िशन कहा जाता है; यहाँ कम्पोज़िशन के कुछ अन्य उदाहरण दिए गए हैं:

• a = int(input(“First number: “))
• print(“Square root of “,a ,” = “,math.sqrt(a))
• print(floor(a+(b/c)))
• math.sin(float(h)/float(c))

पायथन स्टैंडर्ड लाइब्रेरी में उपलब्ध मॉड्यूल्स के अलावा, हम अपने खुद के मॉड्यूल भी बना सकते हैं जिसमें हमारे खुद के फंक्शन हों।

प्रोग्राम 7-16 एक यूज़र-डिफ़ाइंड मॉड्यूल basic_math बनाएँ जिसमें निम्नलिखित यूज़र-डिफ़ाइंड फंक्शन हों:

1. दो संख्याओं को जोड़ना और उनका योग लौटाना।
2. दो संख्याओं को घटाना और उनका अंतर लौटाना।
3. दो संख्याओं को गुणा करना और उनका गुणनफल लौटाना।
4. दो संख्याओं को भाग देना और उनका भागफल लौटाना और यदि हर शून्य हो तो “Division by Zero” त्रुटि प्रिंट करना।
5. मॉड्यूल का वर्णन करने के लिए एक डॉकस्ट्रिंग भी जोड़ें। मॉड्यूल बनाने के बाद, फंक्शन को import करें और निष्पादित करें।

“““Docstrings””” को पायथन डॉक्युमेंटेशन स्ट्रिंग्स भी कहा जाता है। यह एक बहु-पंक्ति टिप्पणी है जो मॉड्यूल्स, फंक्शन आदि का वर्णन करने के लिए जोड़ी जाती है। इन्हें आमतौर पर पहली पंक्ति में 3 डबल कोट्स का उपयोग करके जोड़ा जाता है।

#प्रोग्राम 7-16
#आवश्यकता है:
$\quad$ #1. मॉड्यूल का वर्णन करते हुए एक डॉकस्ट्रिंग लिखें।
$\quad$ #2. विनिर्देश के अनुसार उपयोगकर्ता-परिभाषित फ़ंक्शन लिखें।
$\quad$ #3. फ़ाइल सहेजें।
$\quad$ #4. शेल प्रॉम्प्ट पर आयात करें और फ़ंक्शनों को निष्पादित करें।
$\quad$ basic_math मॉड्यूल
$\quad$ *******************
यह मॉड्यूल मूलभूत अंकगणितीय संक्रियाओं को समाहित करता है
जो संख्याओं पर की जा सकती हैं

”””
#मॉड्यूल की शुरुआत
def addnum(x,y):
$\quad$ return(x + y)
def subnum(x,y):
$\quad$ return(x - y) def multnum(x,y):
$\quad$ return(x * y)
def divnum(x,y):
$\quad$ if y == 0:
$\qquad$ print (“शून्य से विभाजन त्रुटि”)
$\quad$ else:
$\qquad$ return (x/y) $\qquad$ #मॉड्यूल का अंत

आउटपुट:

#basic_math मॉड्यूल का उपयोग करने के लिए कथन
>>> import basic_math
#कहा गया मॉड्यूल का वर्णन प्रदर्शित करें
>>> print(basic_math.doc)

_basic_math मॉड्यूल
*******************
यह मॉड्यूल मूलभूत अंकगणितीय संक्रियाओं को समाहित करता है
जो संख्याओं पर की जा सकती हैं

>>> a = basic_math.addnum(2,5) $\qquad$ #basic_math मॉड्यूल की addnum() फ़ंक्शन को कॉल करें \
>>> a $\hspace{4cm}$ #basic_math मॉड्यूल \
7 \
>>> a = basic_math.subnum(2,5) $\qquad$ #basic_math मॉड्यूल की subnum() फ़ंक्शन को कॉल करें \
>>> a $\hspace{4cm}$ #basic_math मॉड्यूल \
-3 \
>>> a = basic_math.multnum(2,5) $\qquad$ #basic_math मॉड्यूल की multnum() फ़ंक्शन को कॉल करें <br>
>>> a $\hspace{4cm}$ #basic_math मॉड्यूल <br>
10 \
>>> a = basic_math.divnum(2,5) $\qquad$ #basic_math मॉड्यूल की divnum() फ़ंक्शन को कॉल करें <br>
>>> a $\hspace{4cm}$ #basic_math मॉड्यूल \
0.4 \
>>> a = basic_math.divnum(2,0) $\qquad$ #basic_math मॉड्यूल की divnum() फ़ंक्शन को कॉल करें \
_Zero Divide Error $\hspace{2.5cm}$ #basic_math मॉड्यूल_

__doc__ चर डॉकस्ट्रिंग को संग्रहीत करता है। किसी मॉड्यूल की डॉकस्ट्रिंग दिखाने के लिए हमें मॉड्यूल आयात करना होगा और निम्न टाइप करना होगा:

print(< modulename >.__doc__) $\hspace{1.5cm}$  #__ दो अंडरस्कोर हैं, बीच में कोई स्पेस नहीं

सारांश

• प्रोग्रामिंग में, फ़ंक्शन का उपयोग मॉड्यूलरिटी और पुन: उपयोगिता प्राप्त करने के लिए किया जाता है।
• फ़ंक्शन को निर्देशों के एक नामित समूह के रूप में परिभाषित किया जा सकता है जो तब निष्पादित होते हैं जब फ़ंक्शन को उसके नाम से आमंत्रित या कॉल किया जाता है। प्रोग्रामर अपने स्वयं के फ़ंक्शन लिख सकते हैं जिन्हें उपयोगकर्ता-परिभाषित फ़ंक्शन कहा जाता है।
• Python इंटरप्रेटर में कई फ़ंक्शन अंतर्निहित होते हैं। ये वे फ़ंक्शन हैं जो Python प्रोग्राम में प्रायः उपयोग किए जाते हैं। ऐसे फ़ंक्शन बिल्ट-इन फ़ंक्शन कहलाते हैं।
• एक आर्ग्युमेंट वह मान होता है जो फ़ंक्शन कॉल के दौरान फ़ंक्शन को पास किया जाता है और जिसे फ़ंक्शन हेडर में परिभाषित पैरामीटर में प्राप्त किया जाता है।
• Python पैरामीटर को एक डिफ़ॉल्ट मान असाइन करने की अनुमति देता है।
• एक फ़ंक्शन return स्टेटमेंट का उपयोग करके कॉलिंग फ़ंक्शन को मान(मान) वापस करता है।
• Python में एकाधिक मान एक टपल के माध्यम से वापस किए जाते हैं।
• निष्पादन प्रवाह को उस क्रम के रूप में परिभाषित किया जा सकता है जिसमें प्रोग्राम में स्टेटमेंट निष्पादित होते हैं।
• प्रोग्राम का वह भाग जहाँ एक वेरिएबल एक्सेसिबल होता है, वेरिएबल की स्कोप कहलाता है।
• एक वेरिएबल जो किसी विशेष फ़ंक्शन या ब्लॉक के बाहर परिभाषित होता है, उसे ग्लोबल वेरिएबल कहा जाता है। इसे प्रोग्राम में कहीं भी एक्सेस किया जा सकता है।
• एक वेरिएबल जो किसी फ़ंक्शन या ब्लॉक के अंदर परिभाषित होता है, उसे लोकल वेरिएबल कहा जाता है। इसे केवल उसी फ़ंक्शन या ब्लॉक में एक्सेस किया जा सकता है जहाँ यह परिभाषित है। यह तब तक ही मौजूद रहता है जब तक फ़ंक्शन निष्पादित होता है या सक्रिय रहता है।
• Python स्टैंडर्ड लाइब्रेरी फ़ंक्शन और मॉड्यूल का एक विस्तृत संग्रह है जो प्रोग्रामर को प्रोग्राम के तेज़ विकास में मदद करता है।
• एक मॉड्यूल एक Python फ़ाइल होती है जिसमें एकाधिक फ़ंक्शन की परिभाषाएँ होती हैं।
• एक मॉड्यूल को import स्टेटमेंट का उपयोग करके प्रोग्राम में आयात किया जा सकता है।
• इससे कोई फर्क नहीं पड़ता कि एक मॉड्यूल कितनी बार आयात किया जाता है, यह केवल एक बार ही लोड होता है।
• किसी मॉड्यूल से विशिष्ट फ़ंक्शन को प्रोग्राम में आयात करने के लिए, from स्टेटमेंट का उपयोग किया जा सकता है।

अभ्यास

1. निम्नलिखित प्रोग्रामों को ध्यान से देखें और त्रुटि की पहचान करें:

a) def create (text, freq):
$\qquad$ for i in range (1, freq):
$\hspace{1cm}$ print text
create(5) $\hspace{1cm}$ #फंक्शन कॉल

b) from math import sqrt,ceil
def calc():
$\qquad$ print cos(0)
calc() $\hspace{1cm}$ #फंक्शन कॉल

c) mynum = 9
def add9():
$\qquad$ mynum = mynum + 9
$\qquad$ print mynum
add9() $\hspace{1cm}$ #फंक्शन कॉल

d) def findValue( vall = 1.1, val2, val3):
$\qquad$ final = (val2 + val3)/ vall
$\qquad$ print(final)
findvalue() $\hspace{1cm}$ #फंक्शन कॉल

e) def greet():
$\qquad$ return(“Good morning”)
greet() = message $\hspace{1cm}$ #फंक्शन कॉल

2. math.ceil(89.7) और math.floor (89.7) में क्या अंतर है?

3. $\operatorname{random}()$ और randint() में से हमें 1 और 5 के बीच यादृच्छिक संख्या उत्पन्न करने के लिए किस फंक्शन का उपयोग करना चाहिए? औचित्य बताएं।

4. बिल्ट-इन फंक्शन pow() और फंक्शन math.pow() में क्या अंतर है? एक उदाहरण के साथ समझाएं।

5. एक उदाहरण का उपयोग करके दिखाएं कि Python में एक फंक्शन कई मान कैसे लौटा सकता है।

6. एक उदाहरण की सहायता से निम्नलिखित के बीच अंतर बताएं:

a) तर्क और पैरामीटर

b) ग्लोबल और लोकल वेरिएबल

7. क्या एक फंक्शन हमेशा एक मान लौटाता है? एक उदाहरण के साथ समझाएं।

गतिविधि-आधारित प्रश्न

नोट: प्रोग्राम लिखने का अर्थ है:

• दस्तावेज़ के हिस्से के रूप में टिप्पणियाँ जोड़ना
• फ़ंक्शन परिभाषा लिखना
• फ़ंक्शन कॉल के माध्यम से फ़ंक्शन को निष्पादित करना

1. अपने खाते को सुरक्षित करने के लिए, चाहे वह ईमेल हो, ऑनलाइन बैंक खाता हो या कोई अन्य खाता, यह आवश्यक है कि हम प्रमाणीकरण का उपयोग करें। अपने प्रोग्रामिंग ज्ञान का उपयोग करते हुए एक प्रोग्राम बनाएँ जिसमें एक उपयोगकर्ता-परिभाषित फ़ंक्शन हो जिसका नाम login हो और जो userid और password को पैरामीटर के रूप में स्वीकार करता है (login(uid,pwd)) और जो तीन गलत प्रयासों के मामले में “account blocked” संदेश प्रदर्शित करता है। लॉगिन सफल होता है यदि उपयोगकर्ता user ID “ADMIN” और password “StOrE@1” दर्ज करता है। सफल लॉगन पर “login successful” संदेश प्रदर्शित करें।

2. XYZ स्टोर अपने ग्राहकों को त्योहारी छूट देने की योजना बना रहा है। स्टोर प्रबंधन ने निम्नलिखित मानदंडों पर छूट देने का निर्णय लिया है:

स्टोर के सदस्यों को अतिरिक्त $5 %$ की छूट दी जाती है। एक उपयोगकर्ता-परिभाषित फ़ंक्शन का उपयोग करते हुए एक प्रोग्राम बनाएँ जो खरीदारी की राशि को पैरामीटर के रूप में स्वीकार करता है और निम्नलिखित शर्तों के आधार पर छूट और देय राशि की गणना करता है:

Net Payable Amount $=$ Total Shopping Amount Discount.

3. ‘खेलो और सीखो’ रणनीति छोटे बच्चों को मजेदार तरीके से अवधारणाएँ समझने में मदद करती है। एक वरिष्ठ छात्र होने के नाते आपने उपयोगकर्ता-परिभाषित फलनों का उपयोग करके बच्चों को अंग्रेजी वर्णमाला के दो और तीन अक्षरों वाले शब्दों तथा एक अंकीय संख्याओं के योग में निपुण बनाने के लिए एक कार्यक्रम विकसित करने की जिम्मेदारी ली है। सुनिश्चित करें कि आप उम्र और पाठ्यक्रम के अनुसार शामिल किए जा सकने वाले प्रश्नों के प्रकार का सावधानीपूर्वक विश्लेषण करें।

4. नीचे दी गई श्रृंखला को देखें: $1,1,2,3,5,8,13,21,34,55 \ldots$

इस पैटर्न को बनाने के लिए, 1 और 1 लिखकर प्रारंभ करें। उन्हें एक साथ जोड़कर 2 प्राप्त करें। अंतिम दो संख्याओं को जोड़ें: $1+2=3$। अगली संख्या ज्ञात करने के लिए पिछली दो संख्याओं को जोड़ते रहें। ये संख्याएँ प्रसिद्ध फाइबोनैचि अनुक्रम बनाती हैं: तत्काल नई संख्या प्राप्त करने के लिए पिछली दो संख्याओं को जोड़ा जाता है।

5. उपयोगकर्ता-परिभाषित फलनों का उपयोग करके एक मेनू-चालित कार्यक्रम बनाएँ जो निम्नलिखित कार्य करने वाला एक कैलकुलेटर लागू करता है:

a) मूलभूत अंकगणितीय संक्रियाएँ $\left(+,-,{ }^{*}, /\right)$ b) $\log _{10}(\mathrm{x}), \sin (\mathrm{x}), \cos (\mathrm{x})$

सुझाए गए प्रयोगशाला अभ्यास

1. एक ऐसा कार्यक्रम लिखें जो 7 से विभाज्यता की जाँच करे, जिसे उपयोगकर्ता-परिभाषित फलन में पैरामीटर के रूप में पास किया गया है।

2. एक ऐसा कार्यक्रम लिखें जो एक उपयोगकर्ता-परिभाषित फलन का उपयोग करता है जो नाम और लिंग (M पुरुष के लिए, $\mathrm{F}$ महिला के लिए) स्वीकार करता है और लिंग के आधार पर $\mathrm{Mr} / \mathrm{Ms}$ उपसर्ग लगाता है।

3. एक ऐसा कार्यक्रम लिखिए जिसमें एक उपयोगकर्ता-परिभाषित फलन हो जो द्विघात समीकरण के गुणांकों को चरों के रूप में स्वीकार करे और उसका निर्धारक (determinant) गणना करे। उदाहरण के लिए: यदि गुणांक चरों a, b, c में संग्रहित हैं तो निर्धारक को $b^{2}-4 a c$ के रूप में गणना करें। उपयुक्त शर्त लिखिए ताकि निर्धारक को धनात्मक, शून्य और ऋणात्मक के रूप में जाँचा जा सके और उपयुक्त परिणाम आउटपुट किया जा सके।

4. ABC स्कूल ने अपने वार्षिक दिवस समारोह के दिन लकी ड्रॉ की सुविधा के लिए सभी अभिभावकों को (1 से 600 तक) अद्वितीय टोकन आईडी आवंटित की हैं। विजेता को एक विशेष पुरस्कार मिलेगा। Python का उपयोग करके एक ऐसा कार्यक्रम लिखिए जो इस कार्य को स्वचालित करने में मदद करे। (संकेत: random मॉड्यूल का उपयोग करें)

5. एक ऐसा कार्यक्रम लिखिए जो एक उपयोगकर्ता-परिभाषित फलन को लागू करे जो मूलधन, दर, समय और ब्याज की संयोजन बार संख्या को स्वीकार करे और चक्रवृद्धि ब्याज की गणना करके प्रदर्शित करे। (संकेत: CI=P* $\left.(1+r / n)^{n t}\right)$

6. एक ऐसा कार्यक्रम लिखिए जिसमें एक उपयोगकर्ता-परिभाषित फलन हो जो 2 संख्याओं को पैरामीटर के रूप में स्वीकार करे, यदि संख्या 1 संख्या 2 से कम है तो संख्याओं को आपस में बदल दिया जाए, अर्थात् संख्या 2 संख्या 1 के स्थान पर और संख्या 1 संख्या 2 के स्थान पर लौटाई जाए, अन्यथा वही क्रम लौटाया जाए।

7. एक ऐसा कार्यक्रम लिखिए जिसमें वर्ग, आयत, त्रिभुज, वृत्त और बेलन जैसे विभिन्न आकृतियों के लिए क्षेत्रफल, परिमाप या पृष्ठीय क्षेत्रफल (जो भी लागू हो) की गणना करने के लिए उपयोगकर्ता-परिभाषित फ़ंक्शन हों। उपयोगकर्ता-परिभाषित फ़ंक्शन गणना के लिए मानों को पैरामीटर के रूप में स्वीकार करें और गणना किया गया मान वापस लौटाएँ। मॉड्यूल आयात करें और उपयुक्त फ़ंक्शनों का प्रयोग करें।

8. एक ऐसा कार्यक्रम लिखिए जो आपकी पसंद के किन्हीं पाँच प्रश्नों वाला जीके क्विज़ बनाता है। प्रश्नों को यादृच्छिक रूप से प्रदर्शित किया जाना चाहिए। क्विज़ के स्कोर की गणना करने के लिए एक उपयोगकर्ता-परिभाषित फ़ंक्शन score() बनाएँ और एक अन्य उपयोगकर्ता-परिभाषित फ़ंक्शन remark(scorevalue) बनाएँ जो अंतिम स्कोर को स्वीकार कर निम्नलिखित टिप्पणियाँ प्रदर्शित करे:

केस स्टडी-आधारित प्रश्न

अध्याय 6 में विस्तारित SMIS प्रणाली के लिए आइए निम्नलिखित करें:

1. 7.1 अध्याय 5 और 6 की सभी कार्यक्षमताओं को उपयोगकर्ता-परिभाषित फ़ंक्शनों का उपयोग करते हुए रूपांतरित करें।

2. 7.2 ऊपर दिए गए मेनू में एक और उपयोगकर्ता-परिभाषित फ़ंक्शन जोड़ें ताकि यह जाँच हो सके कि किसी छात्र की उपस्थिति कम है या नहीं। यह फ़ंक्शन माह में कुल कार्यरत दिनों की संख्या स्वीकार करेगा और छात्र की उपस्थिति सूत्र—छात्र की उपस्थिति वाले दिनों की गिनती को कुल कार्यरत दिनों से विभाजित कर—के आधार पर यह निर्धारित करेगा कि वह डिफ़ॉल्टर है या नहीं। यदि गणना के परिणामस्वरूप उपस्थिति $78 %$ से कम आती है, तो फ़ंक्शन 1 लौटाएगा जिससे कम उपस्थिति दर्शाई जाएगी; अन्यथा फ़ंक्शन 0 लौटाएगा जिससे यह संकेत मिलेगा कि उपस्थिति कम नहीं है।

आइए अध्याय 5 के अंत में दिए गए “DOCUMENTATION TIPS” के अंतर्गत दिए गए मापदंडों के आधार पर अन्य लोगों के केस-स्टडी का सहकर्मी समीक्षा करें और उन्हें प्रतिक्रिया प्रदान करें।