while लूप — शर्त सच रहने तक चलना

वह समस्या जिसे हम हल कर रहे हैं

पिछले अध्याय में हमने यूज़र का ग़लत इनपुट पकड़ना सीखा — कोई twenty लिखे तो प्रोग्राम कह सकता है "यह नंबर नहीं है"।

लेकिन यह कहने के बाद वह क्या करता है? रुक जाता है। यूज़र को पूरा प्रोग्राम दोबारा चलाना पड़ता है। कोई असली सॉफ़्टवेयर ऐसे नहीं चलता — वह दोबारा पूछता है, और सही जवाब मिलने तक पूछता ही रहता है।

यही लूप का काम है: एक ही काम बार-बार करना, जब तक ज़रूरत हो। आज हम while सीखेंगे — जो चलता है जब तक कोई शर्त सच रहती है।

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

इस अध्याय के बाद आप यह कर पाएँगे

• while लूप लिखना, और बताना कि वह कब रुकेगा
• अनंत लूप (infinite loop) क्यों बनता है यह पहचानना, और Ctrl + C से रोकना
• लूप में जोड़ या गिनती जमा करना
• break और continue सही जगह इस्तेमाल करना
• सही इनपुट मिलने तक पूछते रहना

पहले यह आना चाहिए: निर्णय लेना — if, elif, else।

सबसे आसान लूप

count = 3

while count > 0:
    print(count)
    count = count - 1

print("Go")

3
2
1
Go

बनावट if जैसी ही दिखती है — शर्त, कोलन, इंडेंट किया हुआ ब्लॉक। फ़र्क़ सिर्फ़ एक है, और वही सब कुछ है: if शर्त को एक बार देखता है, while हर बार ब्लॉक ख़त्म होने के बाद उसे फिर से देखता है।

ऊपर वाले प्रोग्राम ने यह किया:

1. count है 3। शर्त 3 > 0 सच → ब्लॉक चला, 3 प्रिंट किया, count बना 2
2. फिर शर्त: 2 > 0 सच → 2 प्रिंट किया, count बना 1
3. फिर शर्त: 1 > 0 सच → 1 प्रिंट किया, count बना 0
4. फिर शर्त: 0 > 0 झूठ → लूप ख़त्म, नीचे वाली लाइन पर गया

काम करने वाले हर while लूप में तीन चीज़ें होती हैं, और तीनों ज़रूरी हैं:

• शुरुआती वैल्यू — लूप से पहले (count = 3)
• शर्त — कब तक चलना है (count > 0)
• बदलाव — अंदर कुछ ऐसा, जो एक दिन शर्त को झूठा कर दे (count = count - 1)

अनंत लूप

तीसरी चीज़ छूट जाए तो क्या होता है, एक बार देख लेना ज़रूरी है:

count = 3

while count > 0:
    print(count)

यह 3 प्रिंट करता ही रहेगा, हमेशा। count कभी नहीं बदलता, इसलिए count > 0 कभी झूठ नहीं होता।

रोकने का तरीक़ा: टर्मिनल में Ctrl + C दबाइए। तुरंत रुक जाएगा और कुछ ऐसा मैसेज दिखाएगा:

Traceback (most recent call last):
  File "D:\python-lab\lesson-10\loop.py", line 4, in <module>
    print(count)
KeyboardInterrupt

File वाली लाइन में आपकी फ़ाइल का पूरा पाथ होगा, और लाइन नंबर इस पर निर्भर है कि आपने ठीक किस पल रोका। KeyboardInterrupt का मतलब है कि आपने ख़ुद रोका। यह आपके कोड का बग नहीं, आपका फ़ैसला है।

अनंत लूप सीखने का एक हिस्सा है। हर प्रोग्रामर ने यह किया है, आज भी करता है। डरने की कोई बात नहीं — Ctrl + C पता हो तो यह बस एक छोटी-सी झुंझलाहट है। लूप लिखते समय बस एक बार ख़ुद से पूछिए: "यह शर्त झूठी कैसे होगी?" जवाब न दे सकें, तो लूप नहीं रुकेगा।

जमा करना

लूप का सबसे आम काम है कुछ जमा करना — जोड़, गिनती, सबसे बड़ी वैल्यू:

total = 0
number = 1

while number <= 5:
    total = total + number
    number = number + 1

print("Sum of 1 to 5:", total)

Sum of 1 to 5: 15

total को accumulator कहते हैं — जमा करने का बर्तन। ध्यान दीजिए, उसे लूप के बाहर 0 से शुरू किया गया है। अंदर शुरू करते तो हर बार वह शून्य हो जाता और आख़िर में सिर्फ़ आख़िरी नंबर बचता।

break — अभी बाहर निकलो

break लूप को तुरंत तोड़ देता है, शर्त चाहे जो कहे:

number = 1

while number <= 100:
    if number % 7 == 0:
        print("First multiple of 7:", number)
        break
    number = number + 1

First multiple of 7: 7

शर्त 100 तक चलने को कह रही थी, लेकिन 7 मिलते ही काम पूरा हो गया — इसलिए 93 बार और घूमने का कोई मतलब नहीं।

break की वजह से एक ऐसा पैटर्न मुमकिन होता है जो बहुत काम का है — शर्त की जगह सीधे True लिख देना, और अंदर सही जगह से बाहर निकलना:

while True:
    answer = input("Type 'quit' to exit: ").strip().lower()
    if answer == "quit":
        print("Goodbye")
        break
    print(f"You typed: {answer}")

Type 'quit' to exit: hello
You typed: hello
Type 'quit' to exit: QUIT
Goodbye

while True का मतलब है "हमेशा चलेगा", इसलिए अंदर एक break ज़रूर होना चाहिए — वरना वह अनंत लूप है।

continue — यह चक्कर छोड़ दो

continue लूप नहीं तोड़ता, बस अंदर की बाक़ी लाइनें छोड़कर सीधे अगले चक्कर पर चला जाता है:

number = 0

while number < 10:
    number = number + 1
    if number % 2 == 0:
        continue
    print(number)

1
3
5
7
9

सम नंबरों पर continue चला, इसलिए print छूट गया।

continue लिखते समय एक जाल है। जो लाइन शर्त को आगे बढ़ाती है (number = number + 1), अगर वह continue के बाद हो, तो continue चलने पर वह छूट जाएगी — और लूप वहीं हमेशा के लिए अटक जाएगा। इसीलिए ऊपर के कोड में बढ़ाने वाली लाइन सबसे पहले रखी गई है। continue इस्तेमाल करें तो यह क्रम हर बार जाँच लीजिए।

आख़िरकार: सही इनपुट मिलने तक पूछना

इसी चीज़ का दो अध्यायों से इंतज़ार था:

while True:
    raw = input("Your age: ").strip()
    if raw.isdigit():
        age = int(raw)
        break
    print("Please type a whole number, digits only.")

print(f"Thank you. Age recorded as {age}.")

Your age: twenty
Please type a whole number, digits only.
Your age: 22.5
Please type a whole number, digits only.
Your age: 22
Thank you. Age recorded as 22.

यही वह पैटर्न है जो आप पूरी ज़िंदगी इस्तेमाल करेंगे: अनंत लूप, अंदर जाँच, सही हो तो break, ग़लत हो तो मैसेज देकर फिर से। प्रोग्राम अब ग़लत इनपुट पर टूटता नहीं, और यूज़र को भी सब कुछ दोबारा शुरू नहीं करना पड़ता।

एक पूरा उदाहरण

shopping.py:

# Keep taking item prices until the user is done, then summarise
total = 0.0
item_count = 0

print("Enter item prices. Type 'done' to finish.")

while True:
    entry = input("Price: ").strip().lower()

    if entry == "done":
        break

    if entry == "":
        print("  Nothing typed — try again.")
        continue

    # Accept only digits and at most one decimal point
    if entry.replace(".", "", 1).isdigit():
        price = float(entry)
        total = total + price
        item_count = item_count + 1
        print(f"  Added {price:.2f}. Running total {total:.2f}")
    else:
        print(f"  '{entry}' is not a price. Try again.")

print()
if item_count == 0:
    print("No items were entered.")
else:
    average = total / item_count
    print(f"Items   : {item_count}")
    print(f"Total   : {total:.2f}")
    print(f"Average : {average:.2f}")

Enter item prices. Type 'done' to finish.
Price: 120
  Added 120.00. Running total 120.00
Price: abc
  'abc' is not a price. Try again.
Price: 85.5
  Added 85.50. Running total 205.50
Price: done

Items   : 2
Total   : 205.50
Average : 102.75

इस प्रोग्राम में तीन चीज़ें साथ काम कर रही हैं, और तीनों आज की सीखी हुई हैं:

• break — यूज़र done लिखे तो लूप से बाहर निकलना
• continue — ख़ाली लाइन मिले तो बाक़ी छोड़कर सीधे फिर से पूछना
• accumulator — total और item_count दोनों लूप के बाहर शुरू होते हैं, अंदर बढ़ते हैं

आख़िरी if item_count == 0 शर्त क्यों ज़रूरी है, एक बार सोचिए। यूज़र कुछ लिखे बिना सीधे done लिख दे तो item_count रहेगा 0, और तब total / item_count ZeroDivisionError देकर प्रोग्राम तोड़ देता। लूप के बाद जमा की हुई वैल्यू इस्तेमाल करने से पहले यह सवाल हर बार पूछना पड़ता है: "क्या एक बार भी कुछ जमा हुआ?"

कुछ टूटी हुई हालतें और उनका हल

प्रोग्राम रुक नहीं रहा, टेक्स्ट भाग रहा है Ctrl + C दबाइए। फिर देखिए कि लूप के अंदर शर्त को आगे बढ़ाने वाली लाइन है या नहीं, और वह continue से पहले है या नहीं।

लूप एक बार भी नहीं चला शर्त शुरू से ही झूठी थी। शुरुआती वैल्यू और शर्त मिलाकर देखिए — while count > 0 लिखकर count = 0 से शुरू करें तो अंदर कभी जाया ही नहीं जाएगा।

एक बार ज़्यादा या एक बार कम चल रहा है < और <= में गड़बड़ हुई है। n = 1 से शुरू करें तो while n < 5 चार बार चलता है (n जब 1, 2, 3, 4 हो), और while n <= 5 पाँच बार। शुरुआती वैल्यू बदलें तो यह गिनती भी बदलती है — n = 0 से शुरू करें तो while n < 5 पाँच बार चलता है। इसलिए शुरुआती वैल्यू और शर्त हमेशा साथ मिलाकर देखिए।

IndentationError: expected an indented block after 'while' statement while के बाद वाली लाइन अंदर नहीं खिसकाई गई।

NameError — लूप के बाद वेरिएबल पहचाना नहीं जा रहा वेरिएबल सिर्फ़ लूप के अंदर बना था, और लूप एक बार भी न चले तो वह कभी बना ही नहीं। जो वेरिएबल लूप के बाद चाहिए, उन्हें लूप से पहले ही कोई शुरुआती वैल्यू दे दीजिए।

लूप के बाद जोड़ ग़लत आ रहा है देखिए कि accumulator लूप के अंदर तो शुरू नहीं किया गया। total = 0 वाली लाइन लूप के बाहर होनी चाहिए।

आपकी बारी

एक नंबर-अंदाज़ा (guessing) गेम लिखिए, guess.py:

1. कोड में 1 से 100 के बीच एक गुप्त नंबर तय कीजिए
2. यूज़र से अंदाज़ा लगाने को कहिए, और हर बार बताइए "ज़्यादा" या "कम"
3. सही अंदाज़ा हो तो बधाई देकर बाहर निकलिए
4. कुल कितनी बार अंदाज़ा लगाया, वह भी प्रिंट कीजिए
5. यूज़र नंबर के अलावा कुछ लिखे तो प्रोग्राम टूटे नहीं — मैसेज देकर फिर से पूछे
6. सात कोशिशों के बाद भी न मिले तो खेल ख़त्म, और गुप्त नंबर बता दीजिए

छठी शर्त आपको सोचने पर मजबूर करेगी: आपका लूप अब दो वजहों से रुक सकता है — सही अंदाज़ा, या कोशिशें ख़त्म। दोनों निकास कैसे सजाएँगे, यही इस अभ्यास का असली सवाल है। और आख़िर में एक बार अपना कोड पढ़कर देखिए: क्या while लूप किसी ऐसी हालत में पहुँच सकता है जहाँ वह हमेशा चलता रहे?