जबकि पायथन में लूप। यह कैसे काम करता है, उपयोग के उदाहरण

लूप्स किसी भी भाषा के मुख्य उपकरणों में से एक हैं। पायथन में दो बुनियादी लूप हैं, जिनमें से एक समय है। इस पर विचार करें, और चित्र की बेहतर समझ के लिए, एक और। दरअसल, कुछ इसी तरह की तुलना में, किसी भी सामग्री को समझना बहुत आसान है, है ना?

एक चक्र की अवधारणा

जब एक निश्चित क्रिया को कई बार करने की आवश्यकता होती है तो एक लूप की आवश्यकता होती है। यह बहुत सरल है, क्योंकि वास्तव में चक्रों के लिए अनुप्रयोगों की सीमा बहुत व्यापक है। पायथन में दो मुख्य प्रकार के लूप हैं: के लिए और जबकि। के लिए सबसे लोकप्रिय है।

विशिष्ट क्रियाओं के अलावा, आप एक निश्चित बिंदु तक कोड के विभिन्न टुकड़ों को लूप कर सकते हैं। यह एक निश्चित संख्या में बार हो सकता है, या जब तक कोई विशेष शर्त सत्य है।

इससे पहले कि हम लूप के प्रकारों को समझना शुरू करें और विशेष रूप से, हमें अभी भी यह समझने की जरूरत है कि पुनरावृत्ति क्या है। यह वर्तमान एप्लिकेशन रन के भीतर वर्तमान चक्र के दौरान किसी क्रिया या क्रियाओं के अनुक्रम की एक पुनरावृत्ति है।

साइकिल के लिए

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

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

>>> स्पाइसोक = [10, 40, 20, 30]

>>> स्पिसोक में तत्व के लिए:

... प्रिंट (तत्व + 2)

...

12

42

22

32

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

हमारे मामले में, सूची 10,40,20,30 संख्याओं का एक क्रम है। प्रत्येक पुनरावृत्ति पर, चर में संबंधित मान दिखाई देता है। उदाहरण के लिए, जैसे ही लूप शुरू होता है, वेरिएबल तत्व मान 10 असाइन किया गया है। अगले पुनरावृत्ति पर, दस संख्या 40 में बदल जाती है, तीसरी बार यह संख्या 20 में बदल जाती है, और अंत में, लूप के अंतिम पुनरावृत्ति पर, यह 30 में बदल जाती है।

चक्र के अंत का संकेत सूची में तत्वों का अंत है।

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

>>> स्पिसोक = [1,2,3,4,5]

या फ़ंक्शन का उपयोग करें लेन (), सूची की लंबाई निर्धारित करने के लिए। लेकिन इस मामले में लूप का उपयोग करना बेहतर है जबकि, क्योंकि चर का उपयोग करने की कोई आवश्यकता नहीं है।

यदि आपको सूची में मूल्यों के अनुक्रम को बदलने की आवश्यकता है, तो लूप एसटी और यहाँ बचाव के लिए आता है। ऐसा करने के लिए, प्रत्येक पुनरावृत्ति पर, सूची के प्रत्येक तत्व को एक उपयुक्त मान निर्दिष्ट किया जाना चाहिए।

घुमाव के दौरान

चक्र के विपरीत एसटी , जो केवल अनुक्रम के मूल्यों पर पुनरावृति करता है, लूप जब अधिक उपयोग हैं। इस प्रकार के चक्रों का नाम "अभी तक" के रूप में अनुवादित किया गया है। यानी "तक"।

यह एक यूनिवर्सल लूप है जो सभी प्रोग्रामिंग लैंग्वेज में पाया जाता है। और कुछ मायनों में यह एक सशर्त ऑपरेटर जैसा दिखता है यू, जो यह देखने के लिए जांच करता है कि कोई निश्चित शर्त पूरी हुई है या नहीं। केवल सशर्त ऑपरेटर के विपरीत, जब प्रत्येक पुनरावृत्ति पर जाँच करता है, न कि केवल एक बार। और केवल अगर शर्त झूठी है, तो लूप समाप्त हो जाता है और इसके बाद आने वाली कमांड निष्पादित होती है। सरल शब्दों में, यदि वह जिस स्थिति में काम करता है वह अब मान्य नहीं है।

यदि हम एक चक्र बनाते हैं जब सरलता से, यह ऐसी योजना का उपयोग करके किया जाता है।

कार्यक्रम की मुख्य शाखा (जो लूप के बाहर चलती है) को इस आकृति में नीले आयतों के साथ दर्शाया गया है। फ़िरोज़ा चक्र के शरीर का प्रतिनिधित्व करता है। बदले में, एक समचतुर्भुज एक ऐसी स्थिति है जिसे प्रत्येक पुनरावृत्ति पर जाँचा जाता है।

चक्र जब दो अपवाद हो सकते हैं:

1. यदि लूप की शुरुआत में तार्किक अभिव्यक्ति सही नहीं होती है, तो यह बस शुरू नहीं होती है, निष्पादन से पहले पूरी हो जाती है। सामान्य तौर पर, यह स्थिति सामान्य है, क्योंकि कुछ परिस्थितियों में, एप्लिकेशन लूप बॉडी में अभिव्यक्तियों की उपस्थिति के लिए प्रदान नहीं कर सकता है।
2. यदि अभिव्यक्ति हमेशा सत्य होती है, तो इससे लूप हो सकता है। यानी चक्र की अंतहीन स्क्रॉलिंग तक। इसलिए ऐसे प्रोग्राम में हमेशा लूप या प्रोग्राम से एक्जिट स्टेटमेंट होना चाहिए। हालाँकि, यह स्थिति तब उत्पन्न होगी जब कार्यक्रम किसी विशेष स्थिति की सच्चाई या असत्य को निर्धारित करने में सक्षम था। यदि वह ऐसा करने में विफल रहती है, तो प्रोग्राम की समाप्ति के साथ एक त्रुटि लौटा दी जाती है। या आप त्रुटि को संभाल सकते हैं, और फिर, यदि ऐसा होता है, तो निश्चित कोड निष्पादित किया जाएगा।

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

जबकि लूप उदाहरण

यहां कोड का एक उदाहरण दिया गया है जो इस मामले में एक त्रुटि को संभालता है।

n = इनपुट ("एक पूर्णांक दर्ज करें:") 

जबकि टाइप (एन)! = इंट:

    प्रयत्न:

        एन = इंट (एन)

    मान को छोड़कर:

        प्रिंट ("गलत प्रविष्टि!")

        n = इनपुट ("एक पूर्णांक दर्ज करें:") 

अगर एन% 2 == 0:

    प्रिंट ("सम")

अन्य:

    प्रिंट ("विषम")

ध्यान रखें कि पायथन जटिल कोड निर्माणों को घोषित करने के लिए कोलन का उपयोग करता है।

उपरोक्त कोड में, हमने एक शर्त के रूप में परिभाषित किया है कि हमें जांचना चाहिए कि संख्या एक पूर्णांक है या नहीं। यदि हां, तो झूठी वापसी की जाती है। नहीं तो सच है।

कोड के दूसरे भाग में, जहां ऑपरेटर का उपयोग किया जाता है if, हमने विभाजन ऑपरेशन के बाद शेष को खोजने के लिए % ऑपरेटर का उपयोग किया। अगला कदम यह जांचना है कि संख्या सम है या नहीं। यदि नहीं, तो इस मामले में शेष एक है। तदनुसार, संख्या विषम है। 

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

यही है, स्थिति होने तक लूप को नियमित रूप से निष्पादित किया जाएगा। इस स्थिति में, यह इस तरह काम करता है। 

यही है, आप विपरीत से जा सकते हैं: एक निश्चित क्रिया को लूप करें जब तक कि घटना झूठी न हो जाए।

कोड पार्सिंग

आइए अब विस्तार से देखें कि यह कोड कैसे काम करता है। ऐसा करने के लिए, हम इसका चरण दर चरण विश्लेषण करेंगे।

1. सबसे पहले, उपयोगकर्ता एक स्ट्रिंग में प्रवेश करता है, जिसे वेरिएबल n द्वारा स्वीकार किया जाता है। 
2. लूप का उपयोग करना जब इस चर के प्रकार की जाँच की जाती है। पहली प्रविष्टि पर, यह बराबर नहीं है int. इसलिए, परीक्षण के परिणामस्वरूप यह पाया जाता है कि यह स्थिति सही है। इसलिए, लूप बॉडी में प्रवेश किया जाता है।
3. एक ऑपरेटर की मदद से कोशिश हम एक स्ट्रिंग को एक संख्या में बदलने की कोशिश कर रहे हैं। यदि ऐसा किया जाता है, तो कोई त्रुटि नहीं होती है। तदनुसार, इसे संसाधित करने की कोई आवश्यकता नहीं है। इसलिए, दुभाषिया लूप की शुरुआत में लौटता है, और चेक के परिणामों के अनुसार, यह पता चलता है कि यह एक पूर्णांक बन गया है। तो चलिए स्टेप 7 पर चलते हैं
4. यदि रूपांतरण असफल रहा, तो एक ValueError फेंक दिया जाता है। इस मामले में, प्रोग्राम प्रवाह को छोड़कर हैंडलर को भेजा जाता है।
5. उपयोगकर्ता एक नया मान दर्ज करता है, जो चर n को सौंपा गया है।
6. दुभाषिया चरण 2 पर लौटता है और फिर से जांच करता है। यदि यह एक पूर्णांक मान है, तो चरण 7 पर जाएँ। यदि नहीं, तो चरण 3 के अनुसार रूपांतरण का पुन: प्रयास किया जाता है।
7. एक ऑपरेटर की मदद से if निर्धारित करता है कि किसी संख्या को 2 से विभाजित करने के बाद शेषफल है या नहीं। 
8. यदि नहीं, तो पाठ "सम" वापस कर दिया जाता है।
9. यदि नहीं, तो "विषम" पाठ वापस कर दिया जाता है।

अब ऐसे ही एक उदाहरण पर विचार करें। यह निर्धारित करने का प्रयास करें कि यह चक्र कितनी बार गुजरेगा?

कुल = 100 

मैं = 0

जबकि मैं <5:

    एन = इंट (इनपुट ())

    कुल = कुल - n

    I = I + 1 

प्रिंट ("शेष", कुल)

सही उत्तर 5 है। प्रारंभ में, चर का मान i - शून्य। दुभाषिया जाँचता है कि क्या चर बराबर है i 4 या उससे कम। यदि हाँ, तो मान वापस कर दिया जाता है। <strong>उद्देश्य</strong>, और लूप तदनुसार निष्पादित किया जाता है। मान एक से बढ़ जाता है।

पहले पुनरावृत्ति के बाद, चर का मान 1 हो जाता है। एक चेक किया जाता है, और प्रोग्राम समझता है कि यह संख्या फिर से 5 से कम है। तदनुसार, लूप बॉडी को दूसरी बार निष्पादित किया जाता है। चूंकि चरण समान हैं, मान भी एक से बढ़ गया है, और चर अब 2 के बराबर है।

यह मान भी पाँच से कम है। फिर लूप को तीसरी बार निष्पादित किया जाता है, चर में जोड़ा जाता है i 1 और इसे मान 3 दिया गया है। यह फिर से पांच से कम है। और इसलिए यह लूप के छठे पुनरावृत्ति की बात आती है, जिस पर वेरिएबल का मान i 5 के बराबर है (आखिरकार, यह मूल रूप से शून्य था, जहाँ तक हमें याद है)। तदनुसार, यह स्थिति परीक्षण पास नहीं करती है, और लूप स्वचालित रूप से समाप्त हो जाता है और अगले चरण में संक्रमण होता है, जो इसके बाहर है (या प्रोग्राम समाप्ति, यदि निम्न चरण प्रदान नहीं किए जाते हैं), किया जाता है।

चक्र विपरीत दिशा में भी हो सकता है। यहां कोड का एक उदाहरण दिया गया है, जहां प्रत्येक अनुवर्ती पुनरावृत्ति के साथ, चर के वर्तमान मान से एक घटाया जाता है। 

कुल = 100 

जबकि कुल> 0:

    एन = इंट (इनपुट ())

    कुल = कुल - n 

प्रिंट ("संसाधन समाप्त")

यह अनुमान लगाने का प्रयास करें कि यह कार्यक्रम क्या करता है! कल्पना कीजिए कि एक चर में कुल प्रोग्राम संसाधन के बारे में जानकारी संग्रहीत है। हर बार दुभाषिया जाँचता है कि संसाधन मौजूद है या नहीं। यदि नहीं, तो पाठ "संसाधन समाप्त हो गया" प्रदर्शित होता है और प्रोग्राम बंद हो जाता है। और लूप के प्रत्येक पुनरावृत्ति के साथ, संसाधन उस संख्या से कम हो जाता है जिसे उपयोगकर्ता निर्दिष्ट करता है।

और अब होमवर्क। उपरोक्त कोड को बदलने का प्रयास करें ताकि चर भौतिक रूप से नकारात्मक न हो सके।