मुख्य सामग्री पर जाएं
मॉड्यूल 2 · पाठ 2 का 4पाठ्यक्रम में 6/36~8 min
मॉड्यूल पाठ (2/4)

जबकि लूप

while लूप एक ब्लॉक को तब तक दोहराता है जब तक स्थिति सही रहती है। उपयोग करें while जब आप पहले से नहीं जानते कि आपको कितने पुनरावृत्तियों की आवश्यकता होगी: राउंड की संख्या उस चीज़ पर निर्भर करती है जो लूप के अंदर बदलती है।

सिंटेक्स

Python
n = 1
while n < 1000:
    n = n * 2
n  # 1024

इंडेंटेड ब्लॉक को बार-बार निष्पादित किया जाता है। प्रत्येक पुनरावृत्ति से पहले Python स्थिति का मूल्यांकन करता है: जैसे ही यह गलत हो जाता है, लूप समाप्त हो जाता है और ब्लॉक के बाद भी निष्पादन जारी रहता है।

सामान्य पैटर्न

मैन्युअल काउंटर — अन्य भाषाओं में क्लासिक for के बराबर:

Python
i = 0
while i < 5:
    print(i)
    i = i + 1

अनंत लूप + आंतरिक निकास स्थिति - स्थिति होने पर उपयोगी कुछ करने के बाद मूल्यांकन किया गया:

Python
acc = 0
while True:
    acc = acc + 1
    if acc * acc > 100:
        break
acc  # 11   (11*11 = 121 is the first square > 100)

break अंतरतम लूप से तुरंत बाहर निकल जाता है (हम इसे अगले में देखेंगे) पाठ)।

क्लासिक गलती: अनंत लूप

यदि स्थिति में वेरिएबल लूप के अंदर नहीं बदलता है, तो प्रोग्राम कभी समाप्त नहीं होता. यह while के साथ नंबर एक बग है:

Python
n = 0
while n < 10:
    print(n)   # n is never modified → infinite loop!

हमारे अभ्यास में एक निष्पादन समयबाह्य है, इसलिए एक अनंत लूप विफल हो जाएगा ब्राउज़र को फ़्रीज़ करने के बजाय एक स्पष्ट संदेश के साथ। लेकिन उत्पादन में ए अनंत लूप एक गंभीर बग है.

अनंत लूप जोखिम और समाप्ति की स्थिति

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

खुद कोशिश करना

व्यायाम#python.m2.l2.e1
प्रयास: 0लोड हो रहा है...

सबसे छोटा पूर्णांक `n >= 1` इस प्रकार ज्ञात करें कि 2**n एक मिलियन से अधिक हो। इसे `परिणाम` पर निर्दिष्ट करें और इसका मूल्यांकन करें (यह 20 होना चाहिए)।

संपादक लोड हो रहा है...
संकेत दिखाएँ

2**20 = 1,048,576, 1,000,000 से अधिक होने वाला पहला है।

3 प्रयासों के बाद समाधान उपलब्ध है

व्यायाम की समीक्षा करें

व्यायाम#python.m2.l2.e2
प्रयास: 0लोड हो रहा है...

`n = 1000` से शुरू करके, पूर्णांक विभाजन (n // 2) के साथ n को आधा करें जब तक कि यह 0 न हो जाए। गिनें कि `चरणों` में कितने पुनरावृत्तियाँ होती हैं। 'कदमों' का मूल्यांकन करें.

संपादक लोड हो रहा है...
संकेत दिखाएँ

1000 → 500 → 250 → 125 → 62 → 31 → 15 → 7 → 3 → 1 → 0: दस चरण।

3 प्रयासों के बाद समाधान उपलब्ध है

अतिरिक्त चुनौती

व्यायाम#python.m2.l2.e3
प्रयास: 0लोड हो रहा है...

Given the variable `n = 32`, write a `while` loop to count how many times you can divide `n` by 2 (using floor division `//`) before `n` becomes less than or equal to 1. Store the count in `divisions` and evaluate it.

संपादक लोड हो रहा है...
संकेत दिखाएँ

The while condition is n > 1. Inside the loop, divide n by 2 and increment divisions by 1.

3 प्रयासों के बाद समाधान उपलब्ध है