Python Nested Loop — अंदर-बाहर loop और patterns

Nested loop चलता कैसे है

नियम सिर्फ एक है: बाहर वाले loop की हर एक बार के लिए अंदर वाला loop पूरा चलता है। बाहर वाला तब तक आगे नहीं बढ़ता जब तक अंदर वाला खत्म न हो जाए।

for i in range(1, 4):          # बाहर वाला
    for j in range(1, 3):      # अंदर वाला — हर i के लिए पूरा चलेगा
        print(f"i={i} j={j}")

Dry run: i=1 → j=1, j=2 · i=2 → j=1, j=2 · i=3 → j=1, j=2. कुल 3 × 2 = 6 बार print हुआ। कुल iterations हमेशा बाहर × अंदर होती हैं — यही वो बात है जो nested loop को धीमा बनाती है।

Star patterns — nested loop का classic use

n = 5
for i in range(1, n + 1):
    for j in range(i):
        print("*", end="")
    print()                    # line बदलने के लिए खाली print

# *
# **
# ***
# ****
# *****

वह end="" सबसे ज़रूरी हिस्सा है: उससे print नई line पर नहीं जाता, और बाहर वाला print() line तोड़ता है। यही गलती सबसे ज़्यादा होती है — end="" भूल गए तो हर star अपनी line पर आएगा।

# उल्टा triangle
for i in range(n, 0, -1):
    print("*" * i)             # यहाँ string multiplication से एक ही line

# pyramid — spaces + stars
for i in range(1, n + 1):
    print(" " * (n - i) + "* " * i)

ध्यान रहे: जहाँ हर line पर एक ही character दोहराना हो, वहाँ अंदर वाले loop की ज़रूरत ही नहीं — "*" * i काफी है। Loop तब लगाओ जब हर position पर अलग चीज़ करनी हो।

Multiplication table और असली डेटा

for n in range(2, 5):              # 2, 3, 4 की tables
    for i in range(1, 6):
        print(f"{n} x {i} = {n * i}")
    print("-" * 12)

# 2D list पर चलना — यही असली ज़रूरत है
grid = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in grid:
    for value in row:
        print(value, end=" ")
    print()

for r, row in enumerate(grid):
    for c, value in enumerate(row):
        print(f"grid[{r}][{c}] = {value}")

break सिर्फ अंदर वाले loop को तोड़ता है

यह बात सबसे ज़्यादा भ्रम पैदा करती है। break सिर्फ उसी loop को बंद करता है जिसमें वह लिखा है — बाहर वाला चलता रहता है:

for i in range(1, 4):
    for j in range(1, 4):
        if j == 2:
            break                # सिर्फ अंदर वाला रुका
        print(i, j)
# 1 1
# 2 1
# 3 1     — बाहर वाला पूरा चला

दोनों loop से एक साथ बाहर निकलना हो तो तीन रास्ते हैं:

# 1. flag का इस्तेमाल
found = False
for i in range(5):
    for j in range(5):
        if i * j > 6:
            found = True
            break
    if found:
        break

# 2. for-else (जब break न लगा हो तभी else चले)
for i in range(5):
    for j in range(5):
        if i * j > 100:
            break
    else:
        continue
    break

# 3. function में डालकर return कर दो — सबसे साफ़
def find(grid, target):
    for row in grid:
        if target in row:
            return True
    return False

तीसरा तरीका सबसे पढ़ने लायक है: function से return सीधे दोनों loop से बाहर निकाल देता है, कोई flag नहीं चाहिए।

Common गलतियाँ

1. अंदर वाले loop में बाहर वाले variable को बदलना — जैसे total = 0 को अंदर reset करना, जिससे हर बार पिछला जोड़ खो जाता है। total को बाहर रखो।
2. print() भूल जाना — pattern एक ही line में चिपक जाएगा। हर बाहर वाली iteration के बाद खाली print() चाहिए।
3. end="" भूल जाना — हर item अपनी line पर आ जाएगा।
4. गलत loop में break — break सिर्फ अपने loop को तोड़ता है, बाहर वाले को नहीं।
5. बड़े डेटा पर तीन-तीन nested loop — n × n × n बहुत जल्दी असंभव हो जाता है; dict या set से O(1) lookup सोचो।

🛠️ Practice करो (free, browser में)

पढ़ना काफी नहीं — यही bug खुद fix करके देखो। नीचे के problems browser में ही चलते हैं, कोई install नहीं, कोई login नहीं।

• Nested loop with a shared variable — सबसे common nested-loop bug।
• Nested dictionary access — nested data पर चलना।

अक्सर पूछे जाने वाले सवाल

आगे पढ़ो

• for loop Hindi में
• break और continue Hindi में
• range() Hindi में
• Star pattern programs
• Loops (English)