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

URL: https://skillaria.top/hi/guides/python/cikly-python

Python में लूप कोई क्रिया बार-बार दोहराते हैं: for किसी कलेक्शन या range() के हर तत्व पर चलता है, जबकि while तब तक चलता है जब तक शर्त सही है। लूप रोकने के लिए break और एक चक्र छोड़ने के लिए continue है, तत्व का क्रमांक enumerate() देता है। निर्णय if/elif/else से लिए जाते हैं, और डेटा का आकार पहचानने के लिए Python 3.10 से 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(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 में शामिल नहीं होती। `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  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 लेक्चर में व्यवहार में समझाए गए हैं।

## FAQ

**for और while में Python में क्या फ़र्क है?**

for तैयार अनुक्रम पर चलता है और जानता है कब रुकना है, जबकि while तब तक दोहराता है जब तक शर्त सही है। अगर दोहराव की संख्या पता है या कलेक्शन है, तो for लें; अगर किसी घटना का इंतज़ार है, तो while।

**Python में लूप उल्टे क्रम में कैसे चलाएँ?**

कलेक्शन के लिए reversed(items), और संख्याओं के लिए range(n - 1, -1, -1) लें। reversed सूची की प्रतिलिपि नहीं बनाता, बल्कि उसे पीछे से पढ़ता है।

**क्या Python में switch है?**

अलग से switch नहीं है। उसका काम if/elif की श्रृंखला और Python 3.10 में आया match/case करता है। match ज़्यादा कर सकता है: सूची और डिक्शनरी को उनके आकार से पहचानता है और मान पकड़ता है।

**लूप तेज़ है या लिस्ट कॉम्प्रिहेंशन?**

[x * 2 for x in items] जैसा कॉम्प्रिहेंशन append वाले समतुल्य लूप से आमतौर पर थोड़ा तेज़ और छोटा होता है। कई शर्तों वाले जटिल तर्क के लिए सामान्य लूप ज़्यादा पढ़ने लायक रहता है।

**दो नेस्टेड लूप से एक साथ कैसे बाहर निकलें?**

break सिर्फ़ भीतरी लूप रोकता है। सबसे आसान तरीका है लूप को फ़ंक्शन में डालें और return से बाहर आएँ।


---
Source: Skillaria.Top (https://skillaria.top)