6.1 परिचय

चित्र 6.1 में, हम बच्चों को स्कूल ले जाने वाली एक बस देखते हैं। स्कूल तक पहुँचने का केवल एक ही रास्ता है। ड्राइवर के पास कोई विकल्प नहीं है, उसे एक के बाद एक मील के पत्थरों का अनुसरण करते हुए स्कूल तक जाना होता है। हमने अध्याय 5 में सीखा था कि यह क्रम (sequence) की अवधारणा है, जहाँ Python प्रोग्राम की शुरुआत से अंत तक एक के बाद एक कथन (statement) को निष्पादित करता है। ये वही प्रकार के प्रोग्राम हैं जो हम अब तक लिखते आए हैं।

चित्र 6.1: छात्रों को स्कूल ले जाती बस

“क्या आपको वह कोड पसंद नहीं है जो सही ढंग से इंडेंट नहीं है? इसे [इंडेंट करना] सिंटैक्स का हिस्सा बना देने से यह सुनिश्चित होता है कि सारा कोड सही ढंग से इंडेंट है।”

$\quad$ - G.van Rossum

आइए एक प्रोग्राम 6-1 पर विचार करें जो क्रमानुसार निष्पादित होता है, अर्थात् कथन उसी क्रम में निष्पादित होते हैं जिसमें वे लिखे गए हैं।

किसी प्रोग्राम में कथनों के निष्पादन की क्रम को नियंत्रण प्रवाह (flow of control) कहा जाता है। नियंत्रण प्रवाह को नियंत्रण संरचनाओं (control structures) का उपयोग करके लागू किया जा सकता है। Python दो प्रकार की नियंत्रण संरचनाओं का समर्थन करता है—चयन (selection) और पुनरावृत्ति (repetition)।

प्रोग्राम 6-1 दो संख्याओं के अंतर को मुद्रित करने का प्रोग्राम।

#प्रोग्राम 6-1
#दो इनपुट संख्याओं के अंतर को प्रिंट करने के लिए प्रोग्राम
num1 = int(input(“पहली संख्या दर्ज करें: “))
num2 = int(input(“दूसरी संख्या दर्ज करें: “))
diff = num1 - num2
print(“का अंतर”,num1,“और”,num2,“है”,diff)

आउटपुट:

पहली संख्या दर्ज करें 5
दूसरी संख्या दर्ज करें 7
5 और 7 का अंतर -2 है

6.2 चयन

अब मान लीजिए हमारे पास एक पेन खरीदने के लिए ₹ 10 हैं। स्टेशनरी की दुकान पर जाने पर, वहाँ ₹10 प्रत्येक कीमत वाले विभिन्न प्रकार के पेन हैं। यहाँ हमें यह तय करना होता है कि कौन-सा पेन खरीदना है। इसी प्रकार, जब हम किसी डिजिटल मानचित्र की दिशा सेवा का उपयोग करते हैं, तो एक स्थान से दूसरे स्थान तक पहुँचने के लिए, हम देखते हैं कि कभी-कभी यह एक से अधिक मार्ग दिखाता है जैसे सबसे कम भीड़ वाला मार्ग, सबसे कम दूरी वाला मार्ग, आदि। हम अपनी प्राथमिकता के अनुसार मार्ग तय करते हैं। एक निर्णय में दो या अधिक संभावित विकल्पों में से एक का चयन शामिल होता है। प्रोग्रामिंग में, इस निर्णय लेने या चयन की अवधारणा if. .else कथन की सहायता से लागू की जाती है।

चित्र 6.2: निर्णय लेने को दर्शाता प्रवाह चार्ट

अब, मान लीजिए हम प्रोग्राम 6-1 में दी गई दो संख्याओं num1 और num2 का धनात्मक अंतर प्रदर्शित करना चाहते हैं। इसके लिए हमें अपने दृष्टिकोण को संशोधित करना होगा। चित्र 6.2 में दिखाए गए प्रवाहचित्र को देखें जो छोटी संख्या को बड़ी संख्या से घटाता है ताकि हमें हमेशा एक धनात्मक अंतर मिले। यह चयन दो संख्याओं num1 और num2 के लिए इनपुट किए गए मानों पर आधारित है।

if कथन का वाक्य-विन्यास है:

if condition:
$\hspace{1cm}$ statement ( s )

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

उदाहरण 6.1

age = int(input(“Enter your age “))
if age >= 18:
$\hspace{1cm}$ print(“Eligible to vote”)

if कथन का एक रूपांतर जिसे if…else कथन कहा जाता है, हमें दो वैकल्पिक पथ लिखने की अनुमति देता है और नियंत्रण शर्त यह निर्धारित करती है कि कौन सा पथ निष्पादित होता है। if…else कथन के लिए वाक्य-विन्यास इस प्रकार है।

if condition:
$\hspace{0.5cm}$ statement(s)
else:
$\hspace{0.5cm}$ statement(s)

आइए अब मतदान के उदाहरण को इस शर्त के साथ संशोधित करें कि यदि उपयोगकर्ता द्वारा दर्ज की गई आयु 18 से अधिक है, तो प्रदर्शित करें कि उपयोगकर्ता मतदान के लिए पात्र है। अन्यथा प्रदर्शित करें कि उपयोगकर्ता मतदान के लिए पात्र नहीं है।

age = int(input(“Enter your age: “))
if age >= 18:
$\hspace{0.5cm}$ print(“Eligible to vote”)
else:
$\hspace{0.5cm}$ print(“Not eligible to vote)

अब आइए इसी अवधारणा का उपयोग कर कार्यक्रम $6-1$ को संशोधित करें, ताकि यह हमेशा सकारात्मक अंतर आउटपुट के रूप में दे। आकृति 6.2 के प्रवाह चित्र से स्पष्ट है कि हमें यह निर्णय लेना होगा कि num $1>$ num 2 है या नहीं और तदनुसार कार्रवाई करनी होगी।

हमें दो ब्लॉकों में कथन निर्दिष्ट करने होंगे क्योंकि num 1, num 2 से बड़ा हो सकता है या इसका विपरीत भी हो सकता है जैसा कि कार्यक्रम 6-2 में दिखाया गया है।

कई बार ऐसी परिस्थितियाँ होती हैं जिनमें कई शर्तों की जाँच करनी पड़ती है और इससे कई विकल्प उत्पन्न हो सकते हैं। ऐसे मामलों में हम if..elif का उपयोग कर शर्तों को श्रृंखलाबद्ध कर सकते हैं (elif का अर्थ है else..if)।

कार्यक्रम 6-2 दो संख्याओं के सकारात्मक अंतर को मुद्रित करने का कार्यक्रम।

#कार्यक्रम 6-2
#दो संख्याओं के सकारात्मक अंतर को मुद्रित करने का कार्यक्रम
num1 = int(input(“Enter first number: “))
num2 = int(input(“Enter second number: “))
if num1 > num2:
$\hspace{0.5cm}$ diff = num1 - num2
else:
$\hspace{0.5cm}$ diff = num2 - num1
print(“The difference of”,num1,“and”,num2,“is”,diff)

आउटपुट:

Enter first number: 5
Enter second number: 6
The difference of 5 and 6 is 1

elif का उपयोग कर चयन संरचना के लिए सिंटैक्स नीचे दिखाया गया है।

if condition:
$\hspace{0.5cm}$ statement(s)
elif condition:
$\hspace{0.5cm}$ statement(s)
elif condition:
$\hspace{0.5cm}$ statement(s)
else:
$\hspace{0.5cm}$ statement(s)

उदाहरण 6.2 जाँचें कि कोई संख्या धनात्मक, ऋणात्मक या शून्य है।

number = int(input(“Enter a number: “)
if number > 0:
$\hspace{0.5cm}$ print(“Number is positive”)
elif number < 0:
$\hspace{0.5cm}$ print(“Number is negative”)
else:
$\hspace{0.5cm}$ print(“Number is zero”)

उदाहरण 6.3 सड़क पार करने के संकेत के रंग के अनुसार उपयुक्त संदेश प्रदर्शित करें।

signal = input(“Enter the colour: “)
if signal == “red” or signal == “RED”:
$\hspace{0.5cm}$ print(“STOP”)
elif signal == “orange” or signal ==
“ORANGE”:
$\hspace{0.5cm}$ print(“Be Slow”)
elif signal == “green” or signal == “GREEN”:
$\hspace{0.5cm}$ print(“Go!”)

elif की संख्या जाँची जाने वाली शर्तों की संख्या पर निर्भर करती है। यदि पहली शर्त गलत है, तो अगली शर्त जाँची जाती है, और इसी तरह। यदि कोई एक शर्त सही है, तो संबंधित इंडेंटेड ब्लॉक चलता है, और if कथन समाप्त हो जाता है।

आइए एक सरल कैलकुलेटर बनाने के लिए एक प्रोग्राम लिखें जो दो संख्याओं पर बुनियादी अंकगणितीय संक्रियाएँ करता है। प्रोग्राम को निम्नलिखित करना चाहिए:

• उपयोगकर्ता से दो संख्याएँ स्वीकार करें।
• उपयोगकर्ता से किसी संक्रियात्मक चिह्न (+, -, *, /) को इनपुट करने को कहें। यदि उपयोगकर्ता कुछ और दर्ज करता है तो एक त्रुटि संदेश प्रदर्शित होता है।
• “-” संक्रियात्मक चिह्न के मामले में केवल धनात्मक अंतर प्रदर्शित करें।
• यदि उपयोगकर्ता दूसरी संख्या 0 दर्ज करता है और ‘/’ संक्रियात्मक चिह्न दर्ज करता है तो “Please enter a value other than 0 " संदेश प्रदर्शित करें।

प्रोग्राम 6-3 चार मूलभूत संक्रियाएँ ही करने वाला एक सरल कैलकुलेटर बनाने के लिए एक प्रोग्राम लिखिए।

#Program to create a four function calculator
result = 0
val1 = float(input(“Enter value 1: “))
val2 = float(input(“Enter value 2: “))
op = input(“Enter any one of the operator (+,-,,/): “)
if op == “+”:
$\hspace{0.5cm}$ result = val1 + val2
elif op == “-”:
$\hspace{0.5cm}$ if val1 > val2:
$\hspace{1cm}$ result = val1 - val2
$\hspace{0.5cm}$ else:
$\hspace{1cm}$ result = val2 - val1
elif op == “”:
$\hspace{1cm}$ result = val1 * val2
elif op == “/”:
$\hspace{0.5cm}$ if val2 == 0:
$\hspace{1cm}$ print(“Error! Division by zero is not allowed. Program terminated”)
$\hspace{0.5cm}$ else:
$\hspace{1cm}$ result = val1/val2
else:
$\hspace{0.5cm}$ print(“Wrong input,program terminated”)
print(“The result is “,result)

आउटपुट:

Enter value 1: 84
Enter value 2: 4
Enter any one of the operator $(+,-, \star, /)$ : /
result is 21.0

प्रोग्राम में, “-” और “/” संचालकों के लिए elif ब्लॉक के भीतर एक if..else स्थिति मौजूद है। इसे नेस्टेड if कहा जाता है। हम if..else कथनों के भीतर कई स्तरों की नेस्टिंग कर सकते हैं।

6.3 इंडेंटेशन

अधिकांश प्रोग्रामिंग भाषाओं में, ब्लॉक के भीतर के कथनों को कर्ली ब्रैकेट्स में रखा जाता है। हालाँकि, Python ब्लॉक के साथ-साथ नेस्टेड ब्लॉक संरचनाओं के लिए भी इंडेंटेशन का उपयोग करता है। किसी कथन की शुरुआत में लीडिंग व्हाइटस्पेस (स्पेस और टैब) को इंडेंटेशन कहा जाता है। Python में, समान स्तर की इंडेंटेशन कथनों को एक ही कोड ब्लॉक से जोड़ती है। इंटरप्रेटर इंडेंटेशन स्तरों की बहुत सख्ती से जाँच करता है और यदि इंडेंटेशन सही नहीं है तो सिंटैक्स एरर देता है। प्रत्येक इंडेंटेशन स्तर के लिए एक टैब का उपयोग करना सामान्य अभ्यास है।

प्रोग्राम 6-4 में, if-else कथन में दो कथनों के ब्लॉक हैं और प्रत्येक ब्लॉक में मौजूद कथन समान संख्या में स्पेस या टैब से इंडेंट किए गए हैं।

प्रोग्राम 6-4 दो पूर्व-निर्धारित संख्याओं में से बड़ी संख्या खोजने के लिए प्रोग्राम।

#प्रोग्राम 6-4
#दो संख्याओं में से बड़ी संख्या खोजने के लिए प्रोग्राम
num1 $=5$
num2 $=6$
if num1 > num2: $\quad$ #ब्लॉक1
print(“पहली संख्या बड़ी है”)
print(“Bye”)
else: $\qquad$ #ब्लॉक2
print(“दूसरी संख्या बड़ी है”)
print(“Bye Bye”)

आउटपुट:

दूसरी संख्या बड़ी है
Bye Bye

6.4 पुनरावृत्ति

अक्सर हम किसी कार्य को दोहराते हैं, उदाहरण के लिए, बिजली का बिल भुगतान, जो हर महीने किया जाता है। आकृति 6.3 तितली के जीवन चक्र को दर्शाती है जिसमें चार चरण शामिल हैं, अर्थात् एक तितली अंडे देती है, इल्ला बन जाती है, प्यूपा बनती है और अंततः एक तितली के रूप में परिपक्व होती है। चक्र तितली द्वारा अंडे देने के साथ फिर से शुरू होता है।

इस प्रकार की पुनरावृत्ति को पुनरावृत्ति (iteration) भी कहा जाता है। किसी प्रोग्राम में कथनों के समूह की पुनरावृत्ति लूपिंग संरचनाओं (looping constructs) का उपयोग करके संभव बनाई जाती है। इसे और समझने के लिए, आइए प्रोग्राम 6-5 को देखें।

चित्र 6.3: प्रकृति में होने वाली पुनरावृत्ति प्रक्रिया

प्रोग्राम 6-5 पहली पाँच प्राकृत संख्याएँ प्रिंट करने के लिए एक प्रोग्राम लिखें।

#प्रोग्राम 6-5
#पहली पाँच प्राकृत संख्याएँ प्रिंट करें
print (1)
print (2)
print (3)
print (4)
print (5)

आउटपुट:

1
2
3
4
5

अगर हमें पहली 100,000 प्राकृत संख्याएँ प्रिंट करने को कहा जाए तो हमें क्या करना चाहिए? 100,000 print कथन लिखना कोई कुशल समाधान नहीं होगा। यह थकाऊ होगा और कार्य करने का सबसे अच्छा तरीका नहीं होगा। लूप या पुनरावृत्ति वाला प्रोग्राम लिखना एक बेहतर समाधान है। प्रोग्राम की तर्क इस प्रकार है:

1. एक चर लें, मान लीजिए count, और उसका मान 1 पर सेट करें।
2. count का मान प्रिंट करें।
3. चर को बढ़ाएँ (count $+=1$)।
4. चरण 2 और 3 को तब तक दोहराएँ जब तक count का मान 100,000 से कम या बराबर है (count $<=100,000$)।

लूपिंग कंस्ट्रक्ट्स एक प्रोग्राम में एक सेट कथनों को बार-बार निष्पादित करने की सुविधा प्रदान करते हैं, जो एक शर्त के आधार पर होता है। लूप में मौजूद कथन तब तक बार-बार निष्पादित होते हैं जब तक कि कोई विशेष तार्किक शर्त सत्य बनी रहती है। यह शर्त एक चर के मान के आधार पर जांची जाती है जिसे लूप का नियंत्रण चर कहा जाता है। जब शर्त असत्य हो जाती है, तो लूप समाप्त हो जाता है। यह प्रोग्रामर की जिम्मेदारी है कि यह सुनिश्चित किया जाए कि यह शर्त अंततः असत्य हो जाए ताकि कोई निकास शर्त हो और यह अनंत लूप न बन जाए। उदाहरण के लिए, यदि हमने count $<=$ 100000 शर्त निर्धारित नहीं की होती, तो प्रोग्राम कभी नहीं रुकता। Python में दो लूपिंग कंस्ट्रक्ट्स होते हैं - for और while।

6.4.1 ‘For’ लूप

for कथन का उपयोग मानों की एक श्रेणी या अनुक्रम पर पुनरावृत्ति करने के लिए किया जाता है। for लूप श्रेणी में मौजूद प्रत्येक आइटम के लिए निष्पादित होता है। ये मान या तो संख्यात्मक हो सकते हैं, या जैसा कि हम बाद के अध्यायों में देखेंगे, वे स्ट्रिंग, सूची या टपल जैसे डेटा प्रकार के तत्व हो सकते हैं।

लूप की प्रत्येक पुनरावृत्ति के साथ, नियंत्रण चर यह जांचता है कि क्या श्रेणी में मौजूद सभी मानों को पार किया गया है या नहीं। जब श्रेणी के सभी आइटम समाप्त हो जाते हैं, तो लूप के भीतर के कथन निष्पादित नहीं होते; नियंत्रण तब for लूप के तुरंत बाद आने वाले कथन को स्थानांतरित कर दिया जाता है। for लूप का उपयोग करते समय, पहले से ही पता होता है कि लूप कितनी बार निष्पादित होगा। for लूप के निष्पादन को दर्शाने वाला फ्लोचार्ट चित्र 6.4 में दिया गया है।

आकृति 6.4: फॉर लूप का प्रवाह चार्ट

(A) फॉर लूप की वाक्य-रचना

for < नियंत्रण-चर > in < अनुक्रम/रेंज में आइटम >:
$\quad$ < लूप के शरीर के भीतर कथन >

कार्यक्रम 6-6 स्ट्रिंग ‘PYTHON’ के अक्षरों को फॉर लूप का उपयोग करके प्रिंट करने का कार्यक्रम।

#कार्यक्रम 6-6
#फॉर लूप का उपयोग करके PYTHON शब्द के अक्षरों को प्रिंट करें
for letter in ‘PYTHON’:
$\quad$ print(letter)

आउटपुट:

P
Y
T
H
O
N

कार्यक्रम 6-7 दी गई अनुक्रम में संख्याओं को फॉर लूप का उपयोग करके प्रिंट करने का कार्यक्रम।

#कार्यक्रम 6-7
#फॉर लूप का उपयोग करके दी गई संख्या अनुक्रम को प्रिंट करें
count = [10,20,30,40,50]
for num in count:
$\quad$ print(num)

आउटपुट:

10
20
30
40
50

कार्यक्रम 6-8 दी गई अनुक्रम में सम संख्याओं को फॉर लूप का उपयोग करके प्रिंट करने का कार्यक्रम।

#कार्यक्रम 6-8
#दी गई अनुक्रम में सम संख्याएँ प्रिंट करें
numbers $=[1,2,3,4,5,6,7,8,9,10]$
for num in numbers:
$\quad$ if (num $\div 2)==0$ :
$\qquad$ print (num,‘is an even Number’)

आउटपुट:

2 is an even Number
4 is an even Number
6 is an even Number
8 is an even Number
10 is an even Number

नोट: लूप का शरीर for कथन के सापेक्ष इंडेंट किया गया है।

(B) Range() फंक्शन

range() पायथन में एक अंतर्निहित फंक्शन है। range() फंक्शन की वाक्य-रचना है:

$$ \text { range([start], stop }[\text {, step }]) $$

इसका उपयोग दिए गए प्रारंभिक मान से रुकने वाले मान तक (रुकने वाले मान को छोड़कर) दिए गए चरण मान के अंतर से पूर्णांकों की एक अनुक्रम युक्त सूची बनाने के लिए किया जाता है। हम अगले अध्याय में फंक्शन के बारे में सीखेंगे। शुरुआत के लिए, बस याद रखें कि फंक्शन काम करने के लिए पैरामीटर लेता है। फंक्शन range() में, start, stop और step पैरामीटर होते हैं।

start और step पैरामीटर वैकल्पिक होते हैं। यदि प्रारंभिक मान निर्दिष्ट नहीं किया गया है, तो डिफ़ॉल्ट रूप से सूची 0 से शुरू होती है। यदि step भी निर्दिष्ट नहीं किया गया है, तो डिफ़ॉल्ट रूप से प्रत्येक पुनरावृत्ति में मान 1 से बढ़ता है। range() फंक्शन के सभी पैरामीटर पूर्णांक होने चाहिए। step पैरामीटर धनात्मक या ऋणात्मक पूर्णांक हो सकता है, शून्य को छोड़कर।

उदाहरण 6.4

#start और step निर्दिष्ट नहीं है
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#डिफ़ॉल्ट step मान 1 है
>>> list(range(2, 10))
[2, 3, 4, 5, 6, 7, 8, 9]

#step मान 5 है
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]

#step मान -1 है। इसलिए, घटता हुआ
#अनुक्रम उत्पन्न होता है
>>> list (range (0, -9, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8]

फंक्शन range() अक्सर for लूप में संख्याओं की एक अनुक्रम उत्पन्न करने के लिए उपयोग किया जाता है।

प्रोग्राम 6-9 दी गई सीमा में संख्याओं के 10 के गुणकों को प्रिंट करने का प्रोग्राम।

#प्रोग्राम 6-9
#दी गई सीमा में संख्याओं के 10 के गुणकों को प्रिंट करें
for num in range(5):
$\quad$ if num > 0:
$\qquad$ print(num * 10)

आउटपुट:

10
20
30
40

6.4.2 ‘While’ लूप

while कथन एक ब्लॉक कोड को तब तक बार-बार चलाता है जब तक लूप का नियंत्रण-प्रतिबंध सत्य है। while लूप का नियंत्रण-प्रतिबंध लूप के अंदर के किसी भी कथन के चलने से पहले परीक्षित होता है। प्रत्येक चक्र के बाद फिर से प्रतिबंध की जाँच की जाती है और जब तक वह सत्य बना रहता है, लूप जारी रहता है। जैसे ही यह प्रतिबंध असत्य हो जाता है, लूप-शरीर के कथन नहीं चलते और नियंत्रण while लूप के शरीर के ठीक बाद वाले कथन पर चला जाता है। यदि while लूप का प्रतिबंध शुरू से ही असत्य है, तो शरीर एक बार भी नहीं चलता।

चित्र 6.5: while लूप का प्रवाह-चित्र

while लूप के शरीर के भीतर के कथनों को यह सुनिश्चित करना चाहिए कि प्रतिबंध अंततः असत्य हो जाए; अन्यथा लूप अनंत लूप बन जाएगा, जिससे प्रोग्राम में तार्किक त्रुटि होगी। while लूप का प्रवाह-चित्र चित्र 6.5 में दिखाया गया है।

while लूप की वाक्य-रचना

while परीक्षण_प्रतिबंध:
    while का शरीर

प्रोग्राम 6-10 while लूप का उपयोग करके पहली 5 प्राकृतिक संख्याओं को छापने का प्रोग्राम।

# प्रोग्राम 6-10
# while लूप का उपयोग करके पहली 5 प्राकृतिक संख्याएँ छापें
count = 1
while count <= 5:
    print(count)
    count += 1

आउटपुट:

1
2
3
4
5

प्रोग्राम 6-11: एक पूर्ण संख्या के गुणनखंड ढूंढने के लिए while लूप का उपयोग करने वाला प्रोग्राम।

#प्रोग्राम 6-11
#while लूप का उपयोग करके किसी संख्या के गुणनखंड ढूंढना
num = int(input("गुणनखंड ढूंढने के लिए एक संख्या दर्ज करें: "))
print(1, end=' ')  #1 हर संख्या का गुणनखंड होता है
factor = 2
while factor <= num/2:
    if num % factor == 0:
        print(factor, end=' ')
    factor += 1
print(num, end=' ')  #हर संख्या स्वयं का गुणनखंड होती है

आउटपुट:

गुणनखंड ढूंढने के लिए एक संख्या दर्ज करें: 6
1 2 3 6

नोट: लूप के बॉडी को while स्टेटमेंट के सापेक्ष इंडेंट किया गया है। इसी प्रकार, if के अंदर के स्टेटमेंट्स को if स्टेटमेंट की स्थिति के सापेक्ष इंडेंट किया गया है।

6.5 break और continue स्टेटमेंट

लूपिंग कंस्ट्रक्ट प्रोग्रामर को कार्यों को दोहराने की क्षमता प्रदान करते हैं। कुछ स्थितियों में, जब कोई विशेष शर्त पूरी होती है, तो हम लूप से बाहर निकलना चाहते हैं (स्थायी रूप से लूप से बाहर आना) या लूप के कुछ स्टेटमेंट्स को छोड़कर आगे बढ़ना चाहते हैं। इन आवश्यकताओं को क्रमशः break और continue स्टेटमेंट्स का उपयोग करके पूरा किया जा सकता है। Python इन स्टेटमेंट्स को प्रदान करता है ताकि प्रोग्रामर को प्रोग्राम के निष्पादन के प्रवाह को नियंत्रित करने में अधिक लचीलापन मिल सके।

6.5.1 break स्टेटमेंट

ब्रेक स्टेटमेंट सामान्य निष्पादन प्रवाह को बदलता है क्योंकि यह वर्तमान लूप को समाप्त करता है और उस लूप के बाद वाले स्टेटमेंट के निष्पादन को फिर से शुरू करता है।

चित्र 6.5: लूप में ब्रेक स्टेटमेंट के उपयोग के लिए फ्लोचार्ट

प्रोग्राम 6-12 ब्रेक स्टेटमेंट के उपयोग को प्रदर्शित करने वाला प्रोग्राम।

#प्रोग्राम 6-12
#लूप में ब्रेक स्टेटमेंट के उपयोग को प्रदर्शित करने वाला प्रोग्राम
num $=0$
for num in range (10):
$\quad$ num $=$ num +1
$\quad$ if num $==8$ :
$\qquad$ break
print(‘Num has value ’ + str(num))
print(‘Encountered break!! Out of loop’)

आउटपुट:

Num has value 1
Num has value 2
Num has value 3
Num has value 4
Num has value 5
Num has value 6
Num has value 7
Encountered break!! Out of loop

नोट: जब num का मान 8 हो जाता है, तो ब्रेक स्टेटमेंट निष्पादित होता है और for लूप समाप्त हो जाता है।

प्रोग्राम 6-13 उपयोगकर्ता द्वारा दर्ज किए गए सभी धनात्मक संख्याओं का योग ज्ञात करें। जैसे ही उपयोगकर्ता एक ऋणात्मक संख्या दर्ज करता है, उपयोगकर्ता से कोई और इनपुट लेना बंद करें और योग प्रदर्शित करें।

#प्रोग्राम 6-13
#उपयोगकर्ता द्वारा दर्ज किए गए सभी धनात्मक संख्याओं का योग ज्ञात करें
#जब तक उपयोगकर्ता एक ऋणात्मक संख्या दर्ज नहीं करता।
entry = 0
sum1 = 0
print(“योग ज्ञात करने के लिए संख्याएँ दर्ज करें, ऋणात्मक संख्या लूप को समाप्त करती है:”)
while True:
#int() स्ट्रिंग को पूर्णांक में टाइपकास्ट करता है
$\quad$ entry = int(input())
$\quad$ if (entry < 0):
$\qquad$ break
$\quad$ sum1 += entry
print(“योग =”, sum1)

आउटपुट:

योग ज्ञात करने के लिए संख्याएँ दर्ज करें, ऋणात्मक संख्या लूप को समाप्त करती है:
3
4
5
-1
योग = 12

प्रोग्राम 6-14 प्रोग्राम यह जांचने के लिए कि इनपुट संख्या अभाज्य है या नहीं।

#प्रोग्राम 6-14
#एक Python प्रोग्राम लिखें जो यह जांचे कि दी गई संख्या अभाज्य है या नहीं। num $=$ int(input(“जांच की जाने वाली संख्या दर्ज करें: “))
flag =0 $\hspace{1cm}$ #मान लीजिए num एक अभाज्य संख्या है
if num $>1$ :
$\quad$ for $i$ in range (2, int (num / 2)):
$\qquad$ if ( num $%$ i $==0$ ):
$\hspace{1cm}$ flag =1 $\hspace{1cm}$ #num अभाज्य संख्या नहीं है
$\hspace{1cm}$ break $\hspace{1cm}$ #आगे जांच करने की आवश्यकता नहीं है
$\qquad$ if flag $==1$ :
$\qquad$ print(num, “अभाज्य संख्या नहीं है”)
$\quad$ else:
$\qquad$ print(num, “एक अभाज्य संख्या है”)
$\quad$ else :
$\qquad$ print(“दर्ज की गई संख्या <=1 है, पुनः निष्पादित करें!”)

आउटपुट 1:

जांच की जाने वाली संख्या दर्ज करें: 20
20 अभाज्य संख्या नहीं है

आउटपुट 2:

जांच की जाने वाली संख्या दर्ज करें: 19
19 एक अभाज्य संख्या है

आउटपुट 3:

जांच की जाने वाली संख्या दर्ज करें: 2
2 एक अभाज्य संख्या है

आउटपुट 4:

संख्या दर्ज करें जाँचने के लिए: 1
दर्ज की गई संख्या $<=1$ है, फिर से चलाएँ!

6.5.2 कंटिन्यू स्टेटमेंट

जब एक कंटिन्यू स्टेटमेंट आता है, तो नियंत्रण वर्तमान पुनरावृत्ति के लिए लूप के भीतर बचे हुए स्टेटमेंट्स के क्रियान्वयन को छोड़ देता है और अगली पुनरावृत्ति के लिए लूप की शुरुआत पर कूद जाता है। यदि लूप की शर्त अभी भी सत्य है, तो लूप फिर से प्रवेश किया जाता है, अन्यथा नियंत्रण लूप के तुरंत बाद वाले स्टेटमेंट को सौंप दिया जाता है। चित्र 6.7 कंटिन्यू स्टेटमेंट का फ्लोचार्ट दिखाता है।

चित्र 6.6: कंटिन्यू स्टेटमेंट का फ्लो चार्ट

प्रोग्राम 6-15 कंटिन्यू स्टेटमेंट के उपयोग को प्रदर्शित करने के लिए प्रोग्राम।

#प्रोग्राम 6-15
0 से 6 तक के मान छापता है सिवाय 3 के
num = 0
for num in range(6):
$\quad$ num = num + 1
$\quad$ if num == 3:
$\qquad$ continue
$\quad$ print(‘Num has value ’ + str(num))
print(‘End of loop’)_

आउटपुट:

Num has value 1
Num has value 2
Num has value 4
Num has value 5
Num has value 6
End of loop

ध्यान दें कि आउटपुट में मान 3 नहीं छपा, लेकिन कंटिन्यू स्टेटमेंट के बाद लूप अन्य मानों को छापना जारी रखता है जब तक कि फॉर लूप समाप्त नहीं होता।

6.6 नेस्टेड लूप्स

एक लूप के अंदर एक और लूप हो सकता है। एक लूप जो दूसरे लूप के अंदर होता है उसे नेस्टेड लूप कहा जाता है।

प्रोग्राम 6-16 नेस्टेड for लूप्स के कामकाज को प्रदर्शित करने के लिए प्रोग्राम।

#प्रोग्राम 6-16
#नेस्टेड for लूप्स के कामकाज को प्रदर्शित करना
for var1 in range(3):
$\quad$ print(“Iteration " + str(var1 + 1) + " of outer loop”)
$\quad$ for var2 in range(2): #nested loop
$\qquad$ print (var2 +1 )
$\quad$ print(“Out of inner loop”)
print(“Out of outer loop”)

आउटपुट:

Iteration 1 of outer loop
1
2
Out of inner loop
Iteration 2 of outer loop
1
2
Out of inner loop
Iteration 3 of outer loop
1
2
Out of inner loop
Out of outer loop

Python किसी लूप के अंदर कितने लूप्स नेस्ट किए जा सकते हैं या नेस्टिंग के स्तरों पर कोई प्रतिबंध नहीं लगाता। कोई भी प्रकार का लूप (for/while) किसी अन्य लूप (for/while) के भीतर नेस्ट किया जा सकता है।

प्रोग्राम 6-17 उपयोगकर्ता द्वारा इनपुट किए गए नंबर के लिए पैटर्न प्रिंट करने के लिए प्रोग्राम।

#प्रोग्राम 6-17
#उपयोगकर्ता द्वारा इनपुट किए गए नंबर के लिए पैटर्न प्रिंट करने के लिए प्रोग्राम
#आउटपुट पैटर्न जो जनरेट करना है
#1
#1 2
#1 2 3
#1 2 3 4
#1 2 3 4 5
num = int(input(“Enter a number to generate its pattern = “))
for i in range(1,num + 1):
$\quad$ for j in range(1,i + 1):
$\qquad$ print(j, end = " “)
$\quad$ print()

आउटपुट:

Enter a number to generate its pattern =5

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

प्रोग्राम 6-18 नेस्टेड for लूप्स का उपयोग कर 2 से 50 के बीच अभाज्य संख्याएँ खोजने के लिए प्रोग्राम।

#प्रोग्राम 6-18
#2 से 50 के बीच अभाज्य संख्याएँ खोजने के लिए नेस्टेड लूप का उपयोग
num = 2
for i in range(2, 50):
$\quad$ j= 2
$\quad$ while ( j <= (i/2)):
$\qquad$ if (i % j == 0): $\hspace{1cm}$ #गुणज मिला
$\hspace{1cm}$ break $\hspace{1cm}$ #while लूप से बाहर निकलें
$\qquad$ j += 1
$\quad$ if ( j > i/j) : $\hspace{1cm}$ #कोई गुणज नहीं मिला
$\hspace{1cm}$ print ( i, “is a prime number”)
print (“Bye Bye!!”)

आउटपुट:

2 is a prime number
3 is a prime number
5 is a prime number
7 is a prime number
11 is a prime number
13 is a prime number
17 is a prime number
19 is a prime number
23 is a prime number
29 is a prime number
31 is a prime number
37 is a prime number
41 is a prime number
43 is a prime number
47 is a prime number
Bye Bye!!

प्रोग्राम 6-19 एक दी गई संख्या का गुणांक (फैक्टोरियल) निकालने के लिए एक प्रोग्राम लिखें।

#प्रोग्राम 6-19
#निम्नलिखित प्रोग्राम एक if..else ब्लॉक के अंदर for लूप का उपयोग करके
#एक दी गई संख्या का गुणांक निकालता है
num = int(input(“Enter a number: “))
fact = 1
#जांचें कि संख्या ऋणात्मक, धनात्मक या शून्य है
if num < 0:
$\quad$ print(“Sorry, factorial does not exist for negative numbers”)
elif num == 0:
$\quad$ print(“The factorial of 0 is 1”)
else:
$\quad$ for i in range(1, num + 1):
$\qquad$ fact = fact * i
$\quad$ print(“factorial of “, num, " is “, fact)

आउटपुट:

Enter a number: 5
Factorial of 5 is 120

सारांश

• if कथन चयन या निर्णय लेने के लिए प्रयोग किया जाता है।
• while और for जैसी लूप संरचनाएँ किसी शर्त के अंतर्गत कोड के अनुभागों को बार-बार निष्पादित होने देती हैं।
• for कथन मानों की एक श्रेणी या अनुक्रम पर पुनरावृत्ति करता है।
• for लूप के निकाय के भीतर के कथन तब तक निष्पादित होते हैं जब तक मानों की श्रेणी समाप्त नहीं हो जाती।
• while के निकाय के भीतर के कथन तब तक बार-बार निष्पादित होते हैं जब तक while की शर्त असत्य नहीं हो जाती।
• यदि while लूप की शुरुआत में ही शर्त असत्य है, तो निकाय एक बार भी निष्पादित नहीं होता।
• while लूप के निकाय के भीतर के कथनों को यह सुनिश्चित करना चाहिए कि शर्त अंततः असत्य हो जाए; अन्यथा लूप अनंत लूप बन जाएगा, जिससे प्रोग्राम में तार्किक त्रुटि होगी।
• break कथन तुरंत लूप से बाहर निकलता है, लूप के निकाय के शेष भाग को छोड़ देता है। निष्पादन लूप के निकाय के ठीक बाद वाले कथन से जारी रहता है। जब continue कथन आता है, तो नियंत्रण अगली पुनरावृत्ति के लिए लूप की शुरुआत पर कूद जाता है।
• एक लूप जो किसी अन्य लूप के भीतर होता है, उसे नेस्टेड लूप कहा जाता है।

अभ्यास

1. if कथन के else और elif निर्माण के बीच क्या अंतर है?

2. range() फ़ंक्शन का उद्देश्य क्या है? एक उदाहरण दीजिए।

3. break और continue कथनों को उदाहरणों द्वारा अंतर स्पष्ट कीजिए।

4. अनंत लूप क्या होता है? एक उदाहरण दीजिए।

5. निम्नलिखित प्रोग्राम खंडों का आउटपुट ज्ञात कीजिए:

(i) a = 110
while a > 100:
$\quad$ print(a)
$\quad$ a -= 2

(ii) for i in range(20,30,2):
$\quad$ print(i)

(iii) country = ‘INDIA’
for i in country:
$\quad$ print (i)

(iv) i = 0; sum = 0
while i < 9:
$\quad$ if i % 4 == 0:
$\qquad$ sum = sum + i
$\quad$ i = i + 2
print (sum)

(v) for x in range(1,4):
$\quad$ for y in range(2,5):
$\qquad$ if x * y > 10:
$\hspace{1cm}$ break
$\qquad$ print (x * y)

(vi) var = 7
while var > 0:
$\quad$ print (‘Current variable value: ‘, var)
$\quad$ var = var -1
$\quad$ if var == 3:
$\qquad$ break
$\quad$ else:
$\qquad$ if var == 6:
$\hspace{1cm}$ var = var -1
$\hspace{1cm}$ continue
$\quad$ print (“Good bye!”)

प्रोग्रामिंग अभ्यास

1. एक ऐसा प्रोग्राम लिखिए जो उपयोगकर्ता का नाम और उम्र इनपुट के रूप में ले और यह संदेश दिखाए कि क्या उपयोगकर्ता ड्राइविंग लाइसेंस के लिए आवेदन करने के योग्य है या नहीं। (योग्य उम्र 18 वर्ष है)।

2. एक फ़ंक्शन लिखिए जो किसी दिए गए संख्या की टेबल प्रिंट करे। संख्या उपयोगकर्ता द्वारा दर्ज की जानी चाहिए।

3. एक ऐसा प्रोग्राम लिखिए जो उपयोगकर्ता द्वारा दर्ज की गई पाँच संख्याओं में से न्यूनतम और अधिकतम प्रिंट करे।

4. एक प्रोग्राम लिखिए जो यह जांचे कि उपयोगकर्ता द्वारा दर्ज किया गया वर्ष लीप वर्ष है या नहीं।

5. एक प्रोग्राम लिखिए जो अनुक्रम उत्पन्न करे: $-5,10$, $-15,20,-25 \ldots$. n तक, जहाँ n उपयोगकर्ता द्वारा दिया गया एक पूर्णांक है।

6. उपयोगकर्ता द्वारा इनपुट किए गए n के लिए $1+1 / 8+$ $1 / 27 \ldots \ldots .1 / \mathrm{n}^{3}$ का योग ज्ञात करने के लिए एक प्रोग्राम लिखिए।

7. उपयोगकर्ता द्वारा इनपुट किए गए पूर्णांक संख्या के अंकों का योग ज्ञात करने के लिए एक प्रोग्राम लिखिए।

8. एक फ़ंक्शन लिखिए जो यह जाँच करे कि इनपुट संख्या पैलिंड्रोम है या नहीं।

[नोट: एक संख्या या स्ट्रिंग को पैलिंड्रोम कहा जाता है यदि उसे उल्टे क्रम में लिखने पर भी वही दिखाई दे। उदाहरण के लिए, 12321 एक पैलिंड्रोम है जबकि 123421 पैलिंड्रोम नहीं है]

9. निम्नलिखित पैटर्न प्रिंट करने के लिए एक प्रोग्राम लिखिए:

10. नीचे दी गई तालिका के अनुसार ग्रेड आवंटित होने पर किसी छात्र का ग्रेड ज्ञात करने के लिए एक प्रोग्राम लिखिए।

छात्र द्वारा प्राप्त अंकों का प्रतिशत प्रोग्राम को इनपुट किया जाता है।

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

आइए अध्याय 5 में विकसित हमारे SMIS में और अधिक कार्यक्षमता जोड़ें।

6.1 एक मेनू-चालित प्रोग्राम लिखिए जिसमें विकल्प हों

• कक्षा X में छात्र के पाँच प्रमुख विषयों में अंक स्वीकार करना और उन्हें प्रदर्शित करना।

• सभी विषयों के अंकों का योग गणना करना। कुल अंकों को विषयों की संख्या (अर्थात् 5) से विभाजित करना, प्रतिशत = कुल अंक / 5 गणना करना और प्रतिशत प्रदर्शित करना।

• निम्नलिखित मानदंडों के अनुसार छात्र का ग्रेड ज्ञात करें:

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