पाइथनमा लुप गर्दा। यसले कसरी काम गर्छ, प्रयोगका उदाहरणहरू

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

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

एक लूप आवश्यक छ जब एक निश्चित कार्य धेरै पटक प्रदर्शन गर्न आवश्यक छ। यो धेरै सरल छ, किनभने वास्तविकता मा चक्र को लागी आवेदन को दायरा धेरै फराकिलो छ। पाइथनमा दुई मुख्य प्रकारका लूपहरू छन्: for and while। लागि सबैभन्दा लोकप्रिय छ।

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

हामीले लूपका प्रकारहरू बुझ्न सुरु गर्नु अघि र विशेष गरी, हामीले अझै पनि पुनरावृत्ति के हो भनेर बुझ्न आवश्यक छ। यो हालको एप्लिकेसन रन भित्र हालको चक्रको समयमा कार्य वा कार्यहरूको अनुक्रमको पुनरावृत्ति हो।

को लागि साइकल

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

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

>>> स्पिसोक = [१०, ४०, २०, ३०]

>>> spisok मा तत्व को लागी:

… छाप्नुहोस् (तत्व + 2)

...

12

42

22

32

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

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

चक्रको अन्त्यको लागि संकेत सूचीमा तत्वहरूको अन्त्य हो।

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

>>> स्पिसोक = [१,२,३,४,५]

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

यदि तपाइँ सूचीमा मानहरूको अनुक्रम परिवर्तन गर्न आवश्यक छ भने, लुप गर्नुहोस् लागि र यहाँ उद्धार गर्न आउँछ। यो गर्नको लागि, प्रत्येक पुनरावृत्तिमा, सूचीको प्रत्येक तत्वलाई उपयुक्त मान तोकिएको हुनुपर्छ।

जबकि लुप

चक्र विपरीत लागि, जसले अनुक्रम, लूपको मानहरूमा मात्र पुनरावृत्ति गर्दछ जबकि थप प्रयोगहरू छन्। यस प्रकारको चक्रको नाम "अझै" को रूपमा अनुवाद गरिएको छ। त्यो हो, "सम्म"।

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

यदि हामी एक चक्र कोर्न जबकि सरल रूपमा, यो यस्तो योजना प्रयोग गरी गरिन्छ।

कार्यक्रमको मुख्य शाखा (जुन लूप बाहिर चल्छ) यो चित्रमा निलो आयतहरूसँग चित्रण गरिएको छ। फिरोजाले चक्रको शरीरलाई प्रतिनिधित्व गर्दछ। बारीमा, एक रोमबस एक अवस्था हो जुन प्रत्येक पुनरावृत्तिमा जाँच गरिन्छ।

चक्र जबकि परिणाम दुई अपवाद हुन सक्छ:

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

त्यहाँ त्रुटि कसरी ह्यान्डल गर्ने विकल्पहरूको ठूलो संख्या हुन सक्छ। उदाहरणका लागि, कार्यक्रमले प्रयोगकर्तालाई डाटा सही रूपमा प्रविष्ट गर्न सोध्न सक्छ। त्यसोभए, यदि एक व्यक्तिले नकारात्मक नम्बर संकेत गरेको छ जहाँ यो केवल सकारात्मक हुन सक्छ, वा अक्षरहरू प्रविष्ट गर्नुहोस् जहाँ केवल संख्याहरू हुनुपर्छ, कार्यक्रमले यसको बारेमा बताउन सक्छ।

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

यहाँ कोड को एक उदाहरण छ जुन यस मामला मा त्रुटि ह्यान्डल गर्दछ।

n = इनपुट ("एक पूर्णांक प्रविष्ट गर्नुहोस्: ") 

जबकि टाइप(n) != int:

    प्रयास गर्नुहोस्:

        n = int(n)

    ValueError बाहेक:

        छाप्नुहोस् ("गलत प्रविष्टि!")

        n = इनपुट ("एक पूर्णांक प्रविष्ट गर्नुहोस्: ") 

यदि n % 2 == 0:

    प्रिन्ट ("भी")

अर्को:

    छाप्नुहोस् ("अनौठो")

ध्यान राख्नुहोस् कि पाइथनले जटिल कोड निर्माणहरू घोषणा गर्न कोलोनहरू प्रयोग गर्दछ।

माथिको कोडमा, हामीले सर्तको रूपमा परिभाषित गरेका छौं कि हामीले जाँच गर्नुपर्छ कि संख्या एक पूर्णांक हो। यदि हो भने, गलत फर्काइन्छ। यदि होइन भने, सत्य।

कोडको दोस्रो भागमा, जहाँ अपरेटर प्रयोग गरिन्छ if, हामीले विभाजन अपरेशन पछि बाँकी फेला पार्न % अपरेटर प्रयोग गर्यौं। अर्को चरण संख्या बराबर छ कि छैन जाँच गर्न छ। यदि होइन भने, यस अवस्थामा बाँकी एक हो। तदनुसार, संख्या अजीब छ। 

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

त्यो हो, अवस्था नआएसम्म लूप नियमित रूपमा कार्यान्वयन हुनेछ। यस अवस्थामा, यो यस्तो काम गर्दछ। 

त्यो हो, तपाईं विपरितबाट जान सक्नुहुन्छ: घटना गलत नभएसम्म एक निश्चित कार्य लुप गर्नुहोस्।

कोड पार्सिङ

अब यो कोडले कसरी काम गर्छ भन्ने बारे थप विस्तारमा हेरौं। यो गर्नको लागि, हामी यसलाई चरण-दर-चरण विश्लेषण गर्नेछौं।

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

अब यस्तो उदाहरण विचार गर्नुहोस्। यो चक्र कति पटक जान्छ भनेर निर्धारण गर्न प्रयास गर्नुहोस्?

कुल = 100 

i = ०

जबकि म <5:

    n = int(इनपुट())

    कुल = कुल - n

    i = i + 1 

छाप्नुहोस् ("बाँकी", कुल)

सहि उत्तर 5 हो। सुरुमा, चरको मान i - शून्य। अनुवादकले चर बराबर छ कि छैन भनेर जाँच गर्दछ i 4 वा कम। यदि हो भने, मान फिर्ता हुन्छ। साँचो, र लूप तदनुसार कार्यान्वयन गरिएको छ। मूल्य एकले बढेको छ।

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

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

चक्र विपरीत दिशामा पनि हुन सक्छ। यहाँ कोडको एउटा उदाहरण हो जहाँ, प्रत्येक पछिको पुनरावृत्तिको साथ, एउटा चरको हालको मानबाट घटाइन्छ। 

कुल = 100 

जबकि कुल > ०:

    n = int(इनपुट())

    कुल = कुल - n 

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

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

र अब गृहकार्य। माथिको कोड परिवर्तन गर्ने प्रयास गर्नुहोस् ताकि चर भौतिक रूपमा नकारात्मक हुन सक्दैन।