Python में लूप और शर्तें: for, while, range, enumerate, break, if/elif और match/case

Python में लूप का काम किसी क्रिया को बार-बार दोहराना है: खरीदारी की सूची के हर आइटम पर जाना, फ़ाइल की हर पंक्ति संसाधित करना, या उपयोगकर्ता से तब तक पूछते रहना जब तक वह सही संख्या न लिखे। भाषा में दो लूप हैं — for और while — और उनके भीतर निर्णय लेने के लिए if/elif/else और match/case हैं। हर औज़ार को व्यावहारिक उदाहरणों से समझते हैं।

शर्तें: if, elif, else

शर्त वाला स्टेटमेंट ब्लॉक तभी चलाता है जब व्यंजन सही हो। ब्लॉक 4 स्पेस के इंडेंटेशन से बनता है — Python में curly braces नहीं होते, और गलत इंडेंटेशन तुरंत IndentationError देता है।

spent = 4200
limit = 5000

if spent > limit:
    print("सीमा पार हो गई")
elif spent > limit * 0.8:
    print("बजट का 20% से कम बचा है")
else:
    print("सब ठीक है")

elif शाखाएँ ऊपर से नीचे जाँची जाती हैं, और सिर्फ़ पहली सही शाखा चलती है। इसलिए सख़्त शर्तें ऊपर रखें: अगर spent > limit * 0.8 की जाँच पहले होती, तो सीमा पार होने वाला संदेश कभी दिखता ही नहीं।

क्या सही माना जाता है

शर्त में तुलना लिखना ज़रूरी नहीं। False, None, शून्य (0, 0.0) और खाली कलेक्शन — "", [], {} — गलत माने जाते हैं। बाक़ी सब सही। इसलिए «सूची खाली नहीं है» की जाँच छोटी लिखी जाती है:

expenses = []
if not expenses:
    print("अभी तक कोई ख़र्च नहीं")

शर्तें and, or, not से जोड़ी जाती हैं, और सीमा की जाँच श्रृंखला-तुलना से आसान होती है: if 0 < amount <= 100_000:। छोटे चुनाव के लिए टर्नरी ऑपरेटर है: status = "ज़्यादा" if spent > limit else "सामान्य"।

Python में for लूप: सिंटैक्स और उदाहरण

Python का for C जैसा गिनती वाला काउंटर नहीं है, बल्कि तत्वों पर चलने वाला लूप है। यह किसी भी इटरेबल वस्तु के तत्व एक-एक करके लेता है: सूची, स्ट्रिंग, डिक्शनरी, फ़ाइल, range। जिसे दूसरी भाषाओं में foreach कहते हैं, वही Python का सामान्य for है।

expenses = [350, 1200, 89, 4500]
total = 0
for amount in expenses:
    total += amount
print(total)  # 6139

for का सिंटैक्स: for वेरिएबल in कलेक्शन:, फिर इंडेंट किया हुआ ब्लॉक। लूप के बाद वेरिएबल अंतिम मान रखता है — कभी-कभी यह काम आता है, पर बड़े प्रोग्राम में इस पर निर्भर नहीं रहना चाहिए।

स्ट्रिंग, सूची और डिक्शनरी पर लूप

स्ट्रिंग पर लूप अक्षर-दर-अक्षर चलता है, सूची पर तत्व-दर-तत्व। डिक्शनरी पर लूप डिफ़ॉल्ट रूप से कुंजियों पर चलता है; कुंजी और मान एक साथ पाने के लिए .items() लें:

by_category = {"खाना": 3200, "यात्रा": 900, "सिनेमा": 600}

for category, amount in by_category.items():
    print(f"{category}: {amount} ₹")

सिर्फ़ मानों के लिए .values() है। लूप चलते समय डिक्शनरी का आकार बदलना मना है — RuntimeError: dictionary changed size during iteration आएगा। तत्व हटाने हों तो प्रतिलिपि पर चलें: for key in list(d):।

range फ़ंक्शन: संख्याओं पर लूप

संख्याओं पर लूप के लिए range() है। यह मेमोरी में सूची नहीं बनाता, बल्कि संख्याएँ एक-एक करके देता है, इसलिए range(10**9) तुरंत शुरू हो जाता है।

मुख्य नियम: दाहिनी सीमा range में शामिल नहीं होती। range(1, 10) 9 पर खत्म होता है — «एक से चूकने» वाली गलती की यह आम वजह है। कदम (step) ऋणात्मक हो सकता है, पर शून्य नहीं।

for i in range(1, 4):
    print(f"दिन {i}")
# दिन 1
# दिन 2
# दिन 3

enumerate: लूप में काउंटर

नए छात्र अक्सर तत्व का क्रमांक जानने के लिए for i in range(len(items)) लिखते हैं। यह काम करता है, पर पढ़ने में कठिन है। enumerate() «क्रमांक, तत्व» के जोड़े देता है, और start पैरामीटर बताता है कि गिनती किस संख्या से शुरू हो:

items = ["कॉफ़ी", "टैक्सी", "भोजन"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 कॉफ़ी
# 2 टैक्सी
# 3 भोजन

दो सूचियों को साथ-साथ पढ़ने के लिए zip() है: for name, price in zip(names, prices):। यह सबसे छोटी सूची पर रुक जाता है; Python 3.10 से strict=True दिया जा सकता है, तब अलग लंबाई पर त्रुटि आती है।

Python में while लूप

while ब्लॉक को तब तक दोहराता है जब तक शर्त सही है। इसे तब चुनते हैं जब दोहराव की संख्या पहले से पता न हो: सही इनपुट का इंतज़ार, डेटा को अंत तक पढ़ना, या सफलता तक अनुरोध दोहराना।

balance = 10_000
month = 0
while balance > 0:
    balance -= 2_700
    month += 1
print(f"पैसे {month} महीने चलेंगे")  # 4

while का सबसे बड़ा ख़तरा है शर्त वाले वेरिएबल को बदलना भूल जाना। तब लूप कभी ख़त्म नहीं होता। प्रोग्राम अटक जाए तो Ctrl+C दबाएँ: Python KeyboardInterrupt के साथ रुक जाएगा।

अनंत लूप और do while

कभी-कभी अनंत लूप जानबूझकर लिखा जाता है: while True: के साथ break से बाहर निकलना। Python में do while नहीं है, और उसकी जगह यही तरीका काम आता है: ब्लॉक कम से कम एक बार चलता है, और जाँच अंत में होती है।

while True:
    raw = input("रकम: ")
    if raw.isdigit():
        amount = int(raw)
        break
    print("कृपया पूर्णांक लिखें")

for लूप शायद ही अनंत होता है — सिर्फ़ तब, जब आप itertools.count() जैसा अनंत इटरेटर चलाएँ।

break और continue: लूप से बाहर आना और चक्र छोड़ना

break लूप को तुरंत रोक देता है, और प्रोग्राम लूप के बाद के कोड से आगे चलता है। continue इस चक्र का बचा हिस्सा छोड़कर अगले चक्र पर चला जाता है।

expenses = [350, -10, 1200, 0, 99_999, 89]

for amount in expenses:
    if amount <= 0:
        continue          # इस चक्र को छोड़ें
    if amount > 50_000:
        print("संदिग्ध रकम, रुकते हैं")
        break             # लूप से बाहर निकलें
    print(amount)

इससे 350 और 1200 छपेंगे, फिर संदेश — 89 तक लूप नहीं पहुँचेगा। दोनों स्टेटमेंट सिर्फ़ उस निकटतम लूप पर असर डालते हैं, जिसके भीतर वे लिखे हैं।

लूप का else

for और while में एक अनोखा else ब्लॉक भी होता है: यह तब चलता है जब लूप बिना break के अपने-आप ख़त्म हुआ हो। खोज के लिए यह बहुत काम का है:

for amount in expenses:
    if amount > 50_000:
        print("बड़ा ख़र्च मिला")
        break
else:
    print("कोई बड़ा ख़र्च नहीं है")

नेस्टेड लूप

लूप के भीतर लूप हर बाहरी चक्र पर भीतरी को पूरा चलाता है। इससे तालिकाएँ, मैट्रिक्स और जोड़े संसाधित होते हैं।

for row in range(1, 4):
    for col in range(1, 4):
        print(row * col, end="\t")
    print()

दो बातें ध्यान रखें। पहली, जटिलता तेज़ी से बढ़ती है: 10 000 तत्वों के दो नेस्टेड लूप का मतलब 100 मिलियन संचालन है। दूसरी, break सिर्फ़ भीतरी लूप से बाहर निकालता है। दोनों लूप रोकने हों तो उन्हें किसी फ़ंक्शन में डालें और return का उपयोग करें — यह फ़्लैग वेरिएबल से साफ़ तरीका है।

match/case स्टेटमेंट

Python 3.10 से लंबी if cmd == ... elif ... श्रृंखला की जगह match स्टेटमेंट (PEP 634) लिखा जा सकता है। यह सिर्फ़ switch नहीं है: यह मान को पैटर्न से मिलाता है, डेटा के आकार के अनुसार और उसके हिस्सों को सीधे वेरिएबल में डाल देता है।

def parse(text):
    match text.split():
        case ["add", item, amount]:
            return f"जोड़ें {item}: {amount}"
        case ["list"] | ["ls"]:
            return "ख़र्च दिखाएँ"
        case ["quit"]:
            return "बाहर निकलें"
        case _:
            return "अज्ञात कमांड"

print(parse("add कॉफ़ी 250"))  # जोड़ें कॉफ़ी: 250
print(parse("add कॉफ़ी"))      # अज्ञात कमांड

सूची-पैटर्न ["add", item, amount] सिर्फ़ तीन तत्वों वाली सूची से मिलेगा, जिसका पहला तत्व "add" हो। इसलिए बिना रकम वाली कमांड _ शाखा में जाती है, जो बाक़ी सब पकड़ती है। | से विकल्प जोड़े जाते हैं।

डिक्शनरी, प्रकार और गार्ड शर्त

डिक्शनरी-पैटर्न सिर्फ़ लिखी गई कुंजियाँ जाँचता है, बाक़ी अनदेखी हो जाती हैं। int(a) प्रकार जाँचता है और मान पकड़ता है, और पैटर्न के बाद if अतिरिक्त शर्त (guard) जोड़ता है:

match event:
    case {"type": "expense", "amount": int(a)} if a > 10_000:
        print("बड़ा ख़र्च", a)
    case {"type": "expense", "amount": int(a)}:
        print("ख़र्च", a)

match का मुख्य जाल

case में अकेला नाम तुलना नहीं, बल्कि कैप्चर है। case limit: हर मान से मिलेगा और उसे limit में लिख देगा। किसी स्थिरांक से तुलना के लिए बिंदु वाला नाम लिखें, जैसे case Color.RED:, या सीधे लिटरल।

Python 3.15 में लिटरल पैटर्न की एक छोटी असमानता दूर हुई है: पहले संख्या से पहले सिर्फ़ ऋण चिह्न मान्य था, अब case +1: भी लिखा जा सकता है। पुराने वर्ज़न पर ऐसा कोड सिंटैक्स एरर देगा।

लूप में आम गलतियाँ

• पहचान के दौरान सूची बदलना। for में तत्व हटाने से बगल वाले छूट जाते हैं। बेहतर है नई सूची बनाना: clean = [x for x in items if x > 0]।
• range की सीमा। range(1, n) में n शामिल नहीं होता।
• while में शर्त बदलना भूल जाना — अनंत लूप।
• लूप में += से स्ट्रिंग जोड़ना बड़ी मात्रा में "".join(parts) से धीमा है।
• तुलना की जगह असाइनमेंट: if x = 5 सिंटैक्स एरर है, तुलना के लिए == लिखा जाता है।

लूप के लिए अभ्यास

1. ख़र्चों की सूची का योग और औसत निकालें, नकारात्मक मान छोड़ते हुए।
2. नेस्टेड लूप से 1 से 9 तक गुणा-सारणी छापें।
3. उपयोगकर्ता से संख्याएँ तब तक पूछें जब तक वह ख़ाली पंक्ति न दे, फिर अधिकतम मान दिखाएँ।
4. सूची में 1000 से बड़ा पहला नंबर खोजें और न मिलने पर बताएँ (for ... else से)।
5. add, del, list कमांड को match से पार्स करें।

निष्कर्ष

Python के लूप दो रूपों तक सीमित हैं: for कलेक्शन या range() के तत्व चलाता है, और while तब तक चलता है जब शर्त सही हो। break और continue लूप का प्रवाह नियंत्रित करते हैं, enumerate() और zip() हाथ से काउंटर लिखने की ज़रूरत हटाते हैं, और if/elif/else तथा match/case निर्णय लेते हैं। ये सभी औज़ार ख़र्च ट्रैकर के उदाहरण पर कोर्स के Python लेक्चर में व्यवहार में समझाए गए हैं।