शर्त के साथ एक लूप। <कोड>जबकि
कथन
for लूप का अध्ययन करते हुए, हमने कहा कि यदि किसी क्रिया के दोहराव की संख्या ज्ञात है, तो आप
for लूप ऑपरेटर का उपयोग करके प्रोग्राम को छोटा कर सकते हैं। लेकिन क्या होगा अगर दोहराव की संख्या अज्ञात है? और ऐसा अक्सर होता है।
उदाहरण
दशमलव संख्या प्रणाली से किसी अन्य में किसी संख्या के अनुवाद को याद करते हुए, हमें संख्या प्रणाली के आधार से संख्या (और फिर विभाजन का परिणाम) को तब तक विभाजित करना होगा जब तक कि हमें उत्तर में शून्य न मिल जाए। हम कितनी बार साझा करेंगे अज्ञात है। और ऐसे कई प्रोग्राम हैं जो इस तरह के एल्गोरिद्म को लागू करते हैं।
अगर हम पुनरावृत्तियों की सटीक संख्या नहीं जानते हैं तो हम एल्गोरिद्म को कैसे लागू कर सकते हैं?
प्रोग्रामिंग में ऐसे मामलों के लिए, एक शर्त के साथ एक लूप स्टेटमेंट होता है।
पायथन प्रोग्रामिंग भाषा में, एक कंडीशनल लूप स्टेटमेंट
while शब्द से शुरू होता है और इसकी संरचना निम्न होती है।
<पूर्व>
<कोड>जबकि <स्थिति>:
लूप बॉडी
जैसा कि हम पहले से ही जानते हैं:
- एक शर्त एक अभिव्यक्ति है, जिसका परिणाम या तो सही या गलत हो सकता है (जैसा कि एक सशर्त बयान में);
- लूप बॉडी वे कमांड हैं जिन्हें दोहराने की आवश्यकता होती है, वे इंडेंट होते हैं।
ऑपरेटर कैसे काम करता है?
1. सबसे पहले, प्रोग्राम शब्द <कोड>जबकि के बाद कोष्ठक में स्थिति का मूल्यांकन करता है। यदि शर्त पूरी होती है (सत्य), तो प्रोग्राम लूप बॉडी में निहित बयानों को निष्पादित करता है।
2. लूप बॉडी का निष्पादन पूरा होने के बाद, प्रोग्राम स्थिति की जांच करने के लिए वापस आता है और इसे फिर से जांचता है।
3. ये क्रियाएं (स्थिति की जांच - लूप बॉडी को निष्पादित करना) तब तक दोहराई जाती हैं जब तक कि स्थिति झूठी नहीं हो जाती।
4. अगर इस स्टेटमेंट के पहले एक्जीक्यूशन के दौरान कंडीशन तुरंत पूरी (गलत) नहीं होती है, तो प्रोग्राम लूप बॉडी को कभी भी एक्जीक्यूट नहीं करेगा।
इस ऑपरेटर के काम का विश्लेषण करते हुए, यह स्पष्ट हो जाना चाहिए कि लूप बॉडी में एक ऑपरेटर होना चाहिए जो स्थिति को प्रभावित करता हो।
उदाहरण के लिए, एक लूप में, किसी स्थिति में उपयोग किए गए वेरिएबल का मान बढ़ाया जा सकता है।
प्रोग्राम का एक उदाहरण जिसे हम
"साइलेंट काउंट" कहेंगे।
आइए, हमारी बजाय प्रोग्राम की गिनती करें, उदाहरण के लिए, 10 तक।
कार्यक्रम को "
प्रारंभ" और "
समाप्त", और इन क्रियाओं के बीच उन संख्याओं को प्रदर्शित करते हैं जिनकी गणना की जा रही है।
उदाहरण के लिए, इस तरह:
शुरू
1 2 3 4 5 6 7 8 9 10
समाप्त
जबकि लूप का उपयोग करने वाला प्रोग्राम इस तरह दिखेगा:
प्रिंट("प्रारंभ")
मैं = 1
जबकि मैं <= 10:
प्रिंट (मैं, अंत = "")
मैं += 1 # ऑपरेटर जो एक चर के परिवर्तन को प्रभावित करता है,
#स्थिति में खड़ा होना
प्रिंट () # कर्सर को एक नई लाइन पर ले जाएं
प्रिंट ("समाप्त")
इस प्रोग्राम में, हम वेरिएबल i = 1 - शुरुआती बिंदु के लिए एक मान निर्दिष्ट करते हैं।
इसके अलावा, जब तक हमारे पास i वेरिएबल का मान हमारे लिए आवश्यक मान से अधिक नहीं है (अर्थात, उससे कम या उसके बराबर), हम:
1. चर i;
का मान प्रदर्शित करें
2. वेरिएबल i के मान को 1 से बढ़ाएँ - यह ऑपरेटर कोष्ठक में स्थिति के मान को प्रभावित करता है। चर i बढ़ा हुआ है, जिसका अर्थ है कि किसी बिंदु पर स्थिति i <= 10 झूठी हो जाएगी। यह तब होगा जब i 11 के बराबर हो जाता है। इस स्थिति में, लूप बॉडी को निष्पादित नहीं किया जाएगा, और प्रोग्राम लूप के बाद अगला स्टेटमेंट निष्पादित करेगा, अर्थात। <कोड>प्रिंट() और <कोड> प्रिंट("समाप्त")।