for लूप और range — निश्चित संख्या में काम दोहराना

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

पिछले अध्याय में 1 से 5 तक का जोड़ निकालने में हमें चार लाइनें लगीं, और उनमें से दो सिर्फ़ हिसाब रखने के लिए थीं — शुरुआती वैल्यू और हर बार एक बढ़ाना। बढ़ाने वाली लाइन भूल गए तो सीधा अनंत लूप (infinite loop)।

लेकिन ध्यान दीजिए, इस तरह के काम में कितनी बार चलेगा, यह हमें पहले से पता होता है। पाँच बार। ऐसी हालत में हिसाब रखने की ज़िम्मेदारी खुद लेने की कोई ज़रूरत नहीं — Python को सौंप दीजिए।

for लूप ठीक यही करता है। और क्योंकि गिनती का काम आपके हाथ में नहीं रहता, range पर चलने वाला for लूप अपने आप अनंत नहीं होता — कितनी बार चलेगा, यह शुरू में ही तय हो जाता है। यही इसका सबसे बड़ा फ़ायदा है। (एक अपवाद है: जिस लिस्ट पर लूप चल रहा है, अगर लूप के अंदर ही उसी लिस्ट में नए आइटम जोड़ते रहें, तो लूप कभी ख़त्म नहीं होता। लिस्ट अगले अध्याय में आ रही है।)

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

• for लूप से कोड को तय संख्या में बार चलाना
• range() के तीनों रूप इस्तेमाल करना
• बताना कि range(1, 5) चार नंबर क्यों देता है, पाँच क्यों नहीं
• स्ट्रिंग के हर अक्षर पर लूप चलाना
• for या while — किस काम में कौन, यह तय करना

पहले यह आना चाहिए: while लूप — शर्त सच रहने तक चलना।

सबसे आसान रूप

for number in range(5):
    print(number)

0
1
2
3
4

तीन लाइनों का काम एक लाइन में, और कोई काउंटर खुद नहीं संभालना पड़ा। इसे ऐसे पढ़िए: "`range(5)` जो नंबर देता है, उनमें से हर एक के लिए ब्लॉक को एक बार चलाओ — और हर बार वह नंबर `number` में रखो।"

दो बातें तुरंत दिखती हैं:

शुरुआत शून्य से होती है, और 5 नहीं आता — कुल पाँच नंबर, लेकिन 0 से 4 तक। Python में हर जगह यही नियम है: जैसे स्लाइस में आख़िरी सीमा छूट जाती है, वैसे ही range में भी।

number नाम आपकी पसंद है। for i in range(5) लिखना भी चलता है, और गिनती के लिए i लिखना आम रिवाज़ है। लेकिन अगर नंबर का कोई मतलब है, तो नाम उसी मतलब से रखिए — for student_number in range(30) पढ़ते ही समझ आ जाता है।

range() के तीन रूप

print("--- range(5) ---")
for i in range(5):
    print(i, end=" ")

print()
print("--- range(2, 6) ---")
for i in range(2, 6):
    print(i, end=" ")

print()
print("--- range(0, 10, 3) ---")
for i in range(0, 10, 3):
    print(i, end=" ")

print()
print("--- range(5, 0, -1) ---")
for i in range(5, 0, -1):
    print(i, end=" ")
print()

--- range(5) ---
0 1 2 3 4 
--- range(2, 6) ---
2 3 4 5 
--- range(0, 10, 3) ---
0 3 6 9 
--- range(5, 0, -1) ---
5 4 3 2 1

नियम:

• range(stop) — 0 से शुरू, stop से पहले ख़त्म
• range(start, stop) — start से शुरू, stop से पहले ख़त्म
• range(start, stop, step) — हर बार step जितना आगे बढ़ता है; step नेगेटिव हो तो पीछे की तरफ़

आख़िरी दो को एक बार मिलाकर देखिए। range(0, 10, 3) देता है 0 3 6 9 — अगला 12 होता, लेकिन वह 10 से आगे निकल जाता है, इसलिए रुक जाता है। और range(5, 0, -1) देता है 5 4 3 2 1 — 0 नहीं आता, क्योंकि आख़िरी सीमा यहाँ भी छूट जाती है।

आख़िरी सीमा क्यों छूटती है? क्योंकि इससे हिसाब आसान होता है। range(0, 5) में कितने नंबर? 5 - 0, यानी पाँच। range(3, 8) में? 8 - 3, पाँच। घटाइए और गिनती मिल जाती है, "एक जोड़ना है या नहीं" सोचना नहीं पड़ता। और दो range साथ-साथ रखें — range(0, 5) और range(5, 10) — तो न कुछ छूटता है, न कुछ दो बार आता है।

अगर एक से दस तक चाहिए

यह ग़लती इतनी बार होती है कि इसे अलग से बताना ज़रूरी है:

print("Wrong — stops at 9:")
for i in range(1, 10):
    print(i, end=" ")

print()
print("Right — includes 10:")
for i in range(1, 11):
    print(i, end=" ")
print()

Wrong — stops at 9:
1 2 3 4 5 6 7 8 9 
Right — includes 10:
1 2 3 4 5 6 7 8 9 10

नियम एक लाइन में: आख़िर में जो नंबर चाहिए, stop में उससे एक ज़्यादा लिखिए।

जोड़ जमा करना — अब आसानी से

total = 0

for number in range(1, 6):
    total = total + number

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

Sum of 1 to 5: 15

while से लिखे इसी काम से मिलाकर देखिए: काउंटर बनाना नहीं, बढ़ाना नहीं, अनंत लूप का डर नहीं। सिर्फ़ एक्यूमुलेटर को पहले की तरह लूप के बाहर शुरू करना होता है।

स्ट्रिंग पर लूप

for सिर्फ़ नंबरों पर नहीं चलता — स्ट्रिंग पर भी चलता है, एक-एक अक्षर करके:

word = "Python"

for letter in word:
    print(letter, end="-")
print()

vowel_count = 0
for letter in "programming":
    if letter in "aeiou":
        vowel_count = vowel_count + 1

print("Vowels:", vowel_count)

P-y-t-h-o-n-
Vowels: 3

यहाँ range नहीं है, क्योंकि ज़रूरत ही नहीं — for letter in word सीधे अक्षरों पर घूमता है। इंडेक्स का हिसाब लगाने से यह आसान है, और IndexError का ख़तरा भी नहीं रहता।

इंडेक्स और अक्षर — दोनों एक साथ चाहिए तो enumerate() है, वह लिस्ट वाले अध्याय में आएगा।

break और continue यहाँ भी चलते हैं

ठीक वैसे ही जैसे while में चलते थे:

for number in range(1, 20):
    if number % 7 == 0:
        print("First multiple of 7:", number)
        break

First multiple of 7: 7

for या while — फ़ैसला कैसे करें

बस एक सवाल पूछिए: कितनी बार चलेगा, यह लूप शुरू होने से पहले पता है?

पता है तो for:

• 5 बार चलाना है
• 1 से 100 तक जाना है
• किसी शब्द का हर अक्षर देखना है
• किसी लिस्ट के हर आइटम पर काम करना है

पता नहीं है तो while:

• सही इनपुट मिलने तक पूछते रहना है
• यूज़र के quit लिखने तक चलते रहना है
• फ़ाइल में लाइनें बची रहने तक पढ़ते रहना है

शक हो तो for चुनिए। वजह सीधी है: range या किसी तय स्ट्रिंग पर चलने वाला for लूप रुकने की गारंटी देता है, while नहीं देता। जहाँ दोनों चल सकते हैं, वहाँ जो कम ग़लती होने दे, वही बेहतर चुनाव है।

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

multiplication.py:

# Print a multiplication table, then a small summary
number = int(input("Which table? "))
upto = int(input("Up to?       "))

print()
print(f"--- Table of {number} ---")

total = 0
for i in range(1, upto + 1):
    result = number * i
    total = total + result
    print(f"{number} x {i:2} = {result:4}")

print()
print(f"Rows    : {upto}")
print(f"Sum     : {total}")
print(f"Average : {total / upto:.2f}")

Which table? 7
Up to?       5

--- Table of 7 ---
7 x  1 =    7
7 x  2 =   14
7 x  3 =   21
7 x  4 =   28
7 x  5 =   35

Rows    : 5
Sum     : 105
Average : 21.00

तीन बातें देखिए। एक, range(1, upto + 1) — upto तक पहुँचने के लिए एक ज़्यादा लिखना पड़ा। दो, {i:2} और {result:4} — f-string के अंदर बता सकते हैं कि नंबर कितनी जगह लेगा, ताकि कॉलम सीधे रहें। तीन, total लूप के बाहर शुरू होता है और अंदर जमा होता है — वही एक्यूमुलेटर।

और खुद से एक सवाल पूछिए: अगर यूज़र Up to? के जवाब में 0 लिखे तो क्या होगा? range(1, 1) कोई नंबर नहीं देता, इसलिए लूप एक बार भी नहीं चलता — और फिर total / upto यानी शून्य से भाग। पिछले अध्याय वाली सीख फिर से: लूप के बाद जमा हुई वैल्यू इस्तेमाल करने से पहले जाँच लीजिए कि कुछ जमा हुआ भी है।

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

आख़िरी नंबर छूट रहा है range(1, 10) 9 पर ख़त्म होता है। stop में एक ज़्यादा दीजिए: range(1, 11)।

TypeError: 'float' object cannot be interpreted as an integer range() सिर्फ़ पूर्णांक (int) लेता है। range(2.5) या range(1, n / 2) नहीं चलेगा — int() से बदलिए, या // से भाग दीजिए।

SyntaxError: expected ':' for वाली लाइन के आख़िर में कोलन नहीं लगा।

IndentationError: expected an indented block after 'for' statement लूप के अंदर वाली लाइन इंडेंट नहीं की गई।

लूप एक बार भी नहीं चला range ख़ाली है। range(5, 0) कुछ नहीं देता — बड़े से छोटे की तरफ़ जाना हो तो तीसरे आर्गुमेंट में -1 देना पड़ता है: range(5, 0, -1)।

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

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

आपकी बारी

stars.py नाम की एक फ़ाइल लिखिए, जो एक नंबर लेकर ऐसा त्रिकोण प्रिंट करे। 5 देने पर:

*
**
***
****
*****

फिर ये तीन काम जोड़िए:

1. कुल कितने तारे प्रिंट हुए, वह नीचे लिखिए (5 के लिए 15)
2. त्रिकोण को उल्टा भी प्रिंट कीजिए — ऊपर पाँच, नीचे एक
3. सम नंबर वाली पंक्तियाँ छोड़कर प्रिंट कीजिए (continue से)

पहला काम जाँचने का एक आसान तरीक़ा है — 1 से 5 का जोड़ हाथ से निकालिए और देखिए कि आपके प्रोग्राम का नंबर उससे मिलता है या नहीं। और "*" * i याद है न? तारों की लाइन बनाने के लिए लूप के अंदर दूसरे लूप की ज़रूरत नहीं।