पाइथन में लूप (Loops in Python)

इस अध्याय में, हम पाइथन में लूप्स (Loops) के उपयोग को समझेंगे। लूप्स प्रोग्रामिंग में कोड को बार-बार निष्पादित करने के लिए उपयोग किए जाते हैं, जब तक कि एक निश्चित शर्त पूरी न हो जाए। पाइथन में मुख्यतः दो प्रकार के लूप्स होते हैं: for लूप और while लूप। इसके अतिरिक्त, हम लूप कंट्रोल स्टेटमेंट्स जैसे break और continue का भी उपयोग करेंगे, जो हमें लूप्स के प्रवाह को नियंत्रित करने की अनुमति देते हैं।

for लूप (for Loop)

पाइथन में for लूप का उपयोग अनुक्रम (sequence) जैसे कि लिस्ट, ट्यूपल, स्ट्रिंग, या रेंज के माध्यम से इटरेट (iterate) करने के लिए किया जाता है। for लूप का उपयोग करके, आप अनुक्रम के प्रत्येक आइटम पर कोड का एक ब्लॉक निष्पादित कर सकते हैं।

सिंटैक्स (Syntax)

for item in sequence:
    # कोड ब्लॉक जो प्रत्येक आइटम के लिए निष्पादित होगा

उदाहरण (Examples)

लिस्ट के माध्यम से इटरेशन (Iteration through a List)

fruits = ["सेब", "केला", "संतरा"]
for fruit in fruits:
    print(fruit)

आउटपुट:

सेब
केला
संतरा

स्ट्रिंग के माध्यम से इटरेशन (Iteration through a String)
```
word = "पाइथन"
for letter in word:
    print(letter)
```
आउटपुट:
```
प
ा
इ
थ
न
```
रेंज के माध्यम से इटरेशन (Iteration through a Range)
```
for i in range(5):
    print(i)
```
आउटपुट:
```
0
1
2
3
4
```

नेस्टेड for लूप्स (Nested for Loops)

आप एक for लूप के अंदर दूसरा for लूप नेस्ट कर सकते हैं। यह तब उपयोगी होता है जब आपको मल्टी-डायमेंशनल डेटा संरचनाओं के माध्यम से इटरेट करना होता है।

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for row in matrix:
    for item in row:
        print(item, end=" ")
    print()

आउटपुट:

1 2 3 
4 5 6 
7 8 9

for लूप के साथ `else` (Using `else` with for Loop)

आप for लूप के साथ else स्टेटमेंट का उपयोग कर सकते हैं। जब लूप सामान्य रूप से समाप्त हो जाता है (किसी break स्टेटमेंट के कारण नहीं), तो else ब्लॉक निष्पादित होता है।

for num in range(5):
    print(num)
else:
    print("लूप समाप्त हो गया।")

आउटपुट:

0
1
2
3
4
लूप समाप्त हो गया।

लूप कंट्रोल स्टेटमेंट्स के साथ for लूप (for Loop with Loop Control Statements)

break स्टेटमेंट break स्टेटमेंट का उपयोग लूप को तुरंत समाप्त करने के लिए किया जाता है। जब break स्टेटमेंट निष्पादित होता है, तो लूप से बाहर निकल जाता है और अगली लाइन पर कोड निष्पादित होता है।
```
for num in range(10):
    if num == 5:
        break
    print(num)
print("लूप समाप्त हो गया।")
```
आउटपुट:
```
0
1
2
3
4
लूप समाप्त हो गया।
```
स्पष्टीकरण: जब num की मान 5 होती है, तो break स्टेटमेंट निष्पादित होता है और लूप तुरंत समाप्त हो जाता है।

continue स्टेटमेंटcontinue स्टेटमेंट का उपयोग वर्तमान पुनरावृत्ति (iteration) को छोड़ने और अगले पुनरावृत्ति के साथ जारी रखने के लिए किया जाता है। जब continue स्टेटमेंट निष्पादित होता है, तो कोड ब्लॉक का शेष भाग छोड़ दिया जाता है और लूप का अगला पुनरावृत्ति शुरू होता है।
```
for num in range(10):
    if num % 2 == 0:
        continue
    print(num)
```
आउटपुट:
```
1
3
5
7
9
```
स्पष्टीकरण: जब num की मान सम संख्या होती है (num % 2 == 0), तो continue स्टेटमेंट निष्पादित होता है और वर्तमान पुनरावृत्ति छोड़ दी जाती है। केवल विषम संख्याएँ प्रिंट होती हैं।
pass स्टेटमेंट pass स्टेटमेंट का उपयोग तब किया जाता है जब आपको कोड ब्लॉक में कुछ भी निष्पादित नहीं करना होता है। यह एक नोपरेशन (no-operation) स्टेटमेंट है और आमतौर पर प्लेसहोल्डर के रूप में उपयोग किया जाता है।
```
for num in range(5):
    if num == 3:
        pass  # यह कुछ नहीं करता, सिर्फ प्लेसहोल्डर है
    print(num)
```
आउटपुट:
```
0
1
2
3
4
```
स्पष्टीकरण: जब num की मान 3 होती है, तो pass स्टेटमेंट निष्पादित होता है, जो कुछ नहीं करता और लूप सामान्य रूप से जारी रहता है।

while लूप (while Loop)

पाइथन में while लूप का उपयोग तब किया जाता है जब हमें एक शर्त के सत्य होने तक कोड का एक ब्लॉक बार-बार निष्पादित करना होता है। while लूप एक कंट्रोल फ्लो स्टेटमेंट है जो शर्त की जांच करता है और शर्त के सत्य रहने तक लूप के अंदर के कोड को निष्पादित करता है।

सिंटैक्स (Syntax)

while condition:
    # कोड ब्लॉक जो शर्त के सत्य होने तक निष्पादित होगा

उदाहरण (Examples)

सरल while लूप (Simple while Loop)

count = 0
while count < 5:
    print(count)
    count += 1

आउटपुट:

यूजर इनपुट के साथ while लूप (while Loop with User Input)

user_input = ""
while user_input.lower() != "quit":
    user_input = input("कुछ लिखें (बंद करने के लिए 'quit' लिखें): ")
    print("आपने लिखा:", user_input)

आउटपुट:

कुछ लिखें (बंद करने के लिए 'quit' लिखें): Hello
आपने लिखा: Hello
कुछ लिखें (बंद करने के लिए 'quit' लिखें): Python
आपने लिखा: Python
कुछ लिखें (बंद करने के लिए 'quit' लिखें): quit
आपने लिखा: quit

सभी सम संख्याओं को प्रिंट करना (Printing All Even Numbers)
```
num = 2
while num <= 10:
    print(num)
    num += 2
```
आउटपुट:
```
2
4
6
8
10
```

नेस्टेड while लूप्स (Nested while Loops)

आप एक while लूप के अंदर दूसरा while लूप नेस्ट कर सकते हैं। यह तब उपयोगी होता है जब आपको मल्टी-डायमेंशनल डेटा संरचनाओं के माध्यम से इटरेट करना होता है।

i = 1
while i <= 3:
    j = 1
    while j <= 3:
        print(f"i={i}, j={j}")
        j += 1
    i += 1

आउटपुट:

i=1, j=1
i=1, j=2
i=1, j=3
i=2, j=1
i=2, j=2
i=2, j=3
i=3, j=1
i=3, j=2
i=3, j=3

while लूप के साथ `else` (Using `else` with while Loop)

आप while लूप के साथ else स्टेटमेंट का उपयोग कर सकते हैं। जब लूप सामान्य रूप से समाप्त हो जाता है (किसी break स्टेटमेंट के कारण नहीं), तो else ब्लॉक निष्पादित होता है।

count = 0
while count < 5:
    print(count)
    count += 1
else:
    print("लूप समाप्त हो गया।")

आउटपुट:

0
1
2
3
4
लूप समाप्त हो गया।

लूप कंट्रोल स्टेटमेंट्स के साथ while लूप (while Loop with Loop Control Statements)

break स्टेटमेंट break स्टेटमेंट का उपयोग लूप को तुरंत समाप्त करने के लिए किया जाता है। जब break स्टेटमेंट निष्पादित होता है, तो लूप से बाहर निकल जाता है और अगली लाइन पर कोड निष्पादित होता है।
```
count = 0
while count < 10:
    if count == 5:
        break
    print(count)
    count += 1
print("लूप समाप्त हो गया।")
```
आउटपुट:
```
0
1
2
3
4
लूप समाप्त हो गया।
```
स्पष्टीकरण: जब count की मान 5 होती है, तो break स्टेटमेंट निष्पादित होता है और लूप तुरंत समाप्त हो जाता है।
continue स्टेटमेंट continue स्टेटमेंट का उपयोग वर्तमान पुनरावृत्ति (iteration) को छोड़ने और अगले पुनरावृत्ति के साथ जारी रखने के लिए किया जाता है। जब continue स्टेटमेंट निष्पादित होता है, तो कोड ब्लॉक का शेष भाग छोड़ दिया जाता है और लूप का अगला पुनरावृत्ति शुरू होता है।
```
count = 0
while count < 10:
    count += 1
    if count % 2 == 0:
        continue
    print(count)
```
आउटपुट:
```
1
3
5
7
9
```
स्पष्टीकरण: जब count की मान सम संख्या होती है (count % 2 == 0), तो continue स्टेटमेंट निष्पादित होता है और वर्तमान पुनरावृत्ति छोड़ दी जाती है। केवल विषम संख्याएँ प्रिंट होती हैं।
pass स्टेटमेंट pass स्टेटमेंट का उपयोग तब किया जाता है जब आपको कोड ब्लॉक में कुछ भी निष्पादित नहीं करना होता है। यह एक नोपरेशन (no-operation) स्टेटमेंट है और आमतौर पर प्लेसहोल्डर के रूप में उपयोग किया जाता है।
```
count = 0
while count < 5:
    count += 1
    if count == 3:
        pass  # यह कुछ नहीं करता, सिर्फ प्लेसहोल्डर है
    print(count)
```
आउटपुट:
```
1
2
3
4
5
```
स्पष्टीकरण: जब count की मान 3 होती है, तो pass स्टेटमेंट निष्पादित होता है, जो कुछ नहीं करता और लूप सामान्य रूप से जारी रहता है।

नेस्टेड लूप्स (Nested Loops)

नेस्टेड लूप्स (Nested Loops) का उपयोग तब किया जाता है जब हमें एक लूप के अंदर दूसरा लूप चलाना होता है। नेस्टेड लूप्स का उपयोग अक्सर तब किया जाता है जब हमें मल्टी-डायमेंशनल डेटा संरचनाओं के माध्यम से इटरेट (iterate) करना होता है, जैसे कि लिस्ट ऑफ लिस्ट्स या मैट्रिक्स।

सिंटैक्स (Syntax)

for outer_variable in outer_sequence:
    for inner_variable in inner_sequence:
        # कोड ब्लॉक जो इनर लूप के प्रत्येक आइटम के लिए निष्पादित होगा

या

while outer_condition:
    while inner_condition:
        # कोड ब्लॉक जो इनर लूप के प्रत्येक पुनरावृत्ति के लिए निष्पादित होगा

उदाहरण (Examples)

नेस्टेड for लूप्स (Nested for Loops)

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for row in matrix:
    for item in row:
        print(item, end=" ")
    print()

आउटपुट:

1 2 3 
4 5 6 
7 8 9

नेस्टेड while लूप्स (Nested while Loops)

i = 1
while i <= 3:
    j = 1
    while j <= 3:
        print(f"i={i}, j={j}")
        j += 1
    i += 1

आउटपुट:

i=1, j=1
i=1, j=2
i=1, j=3
i=2, j=1
i=2, j=2
i=2, j=3
i=3, j=1
i=3, j=2
i=3, j=3

नेस्टेड for और while लूप्स का मिश्रण (Mixing Nested for and while Loops)

numbers = [1, 2, 3]
i = 0

for num in numbers:
    while i < len(numbers):
        print(f"num={num}, i={i}")
        i += 1

आउटपुट:

num=1, i=0
num=1, i=1
num=1, i=2

नेस्टेड लूप्स के साथ ब्रेक और कंटिन्यू स्टेटमेंट्स (Break and Continue Statements with Nested Loops)

नेस्टेड लूप्स के साथ break स्टेटमेंट (Break Statement with Nested Loops)
```
for i in range(3):
    for j in range(3):
        if j == 1:
            break
        print(f"i={i}, j={j}")
```
आउटपुट:
```
i=0, j=0
i=1, j=0
i=2, j=0
```
स्पष्टीकरण: जब j की मान 1 होती है, तो इनर लूप को break स्टेटमेंट द्वारा समाप्त कर दिया जाता है और आउटर लूप की अगली पुनरावृत्ति शुरू होती है।
नेस्टेड लूप्स के साथ continue स्टेटमेंट (Continue Statement with Nested Loops)
```
for i in range(3):
    for j in range(3):
        if j == 1:
            continue
        print(f"i={i}, j={j}")
```
आउटपुट:
```
i=0, j=0
i=0, j=2
i=1, j=0
i=1, j=2
i=2, j=0
i=2, j=2
```
स्पष्टीकरण: जब j की मान 1 होती है, तो इनर लूप के वर्तमान पुनरावृत्ति को continue स्टेटमेंट द्वारा छोड़ दिया जाता है और लूप का अगला पुनरावृत्ति शुरू होता है।

नेस्टेड लूप्स के साथ जटिल डेटा संरचनाओं का उपयोग (Using Nested Loops with Complex Data Structures)

नेस्टेड लूप्स का उपयोग जटिल डेटा संरचनाओं जैसे कि लिस्ट ऑफ लिस्ट्स, डिक्शनरीज ऑफ लिस्ट्स, आदि के माध्यम से इटरेट करने के लिए किया जा सकता है।

data = {
    "fruits": ["सेब", "केला", "संतरा"],
    "vegetables": ["गाजर", "मटर", "आलू"]
}

for category, items in data.items():
    print(f"{category}:")
    for item in items:
        print(f"  {item}")

आउटपुट:

fruits:
  सेब
  केला
  संतरा
vegetables:
  गाजर
  मटर
  आलू

लूप्स के साथ फंक्शंस (Loops with Functions)

पाइथन में लूप्स और फंक्शंस का संयोजन प्रोग्रामिंग को और भी शक्तिशाली और लचीला बनाता है। लूप्स का उपयोग करते हुए, आप एक फंक्शन को बार-बार कॉल कर सकते हैं, और फंक्शंस का उपयोग करते हुए, आप कोड को पुन: उपयोगी और मॉड्यूलर बना सकते हैं। इस सेक्शन में, हम देखेंगे कि कैसे लूप्स और फंक्शंस को एक साथ उपयोग किया जा सकता है।

सिंटैक्स (Syntax)

def function_name(parameters):
    # फंक्शन बॉडी

for item in sequence:
    function_name(arguments)

या

def function_name(parameters):
    # फंक्शन बॉडी

while condition:
    function_name(arguments)

उदाहरण (Examples)

for लूप के साथ फंक्शन (Function with for Loop)

def greet(name):
    print(f"नमस्ते, {name}!")

names = ["राम", "सीता", "लक्ष्मण"]

for name in names:
    greet(name)

आउटपुट:

नमस्ते, राम!
नमस्ते, सीता!
नमस्ते, लक्ष्मण!

while लूप के साथ फंक्शन (Function with while Loop)

def count_down(number):
    while number > 0:
        print(number)
        number -= 1
    print("समय समाप्त!")

count_down(5)

आउटपुट:

5
4
3
2
1
समय समाप्त!

नेस्टेड लूप्स के साथ फंक्शन (Function with Nested Loops)

def print_matrix(matrix):
    for row in matrix:
        for item in row:
            print(item, end=" ")
        print()

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print_matrix(matrix)

आउटपुट:

1 2 3 
4 5 6 
7 8 9

फंक्शन के अंदर लूप (Loop Inside Function)

def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

number = 5
print(f"{number} का फैक्टोरियल है {factorial(number)}")

आउटपुट:

5 का फैक्टोरियल है 120

लूप्स और फंक्शंस के साथ जटिल समस्याओं को हल करना (Solving Complex Problems with Loops and Functions)

लूप्स और फंक्शंस का उपयोग करके, आप जटिल समस्याओं को आसानी से हल कर सकते हैं और कोड को अधिक संगठित बना सकते हैं।

def is_prime(number):
    if number <= 1:
        return False
    for i in range(2, int(number ** 0.5) + 1):
        if number % i == 0:
            return False
    return True

def find_primes_in_range(start, end):
    primes = []
    for num in range(start, end + 1):
        if is_prime(num):
            primes.append(num)
    return primes

start = 10
end = 50
primes = find_primes_in_range(start, end)
print(f"{start} से {end} तक के सभी प्राइम नंबर: {primes}")

आउटपुट:

10 से 50 तक के सभी प्राइम नंबर: [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

लूप्स के लिए उपयोगी टिप्स (Useful Tips for Loops)

लूप्स का उपयोग करते समय कुछ उपयोगी टिप्स और सर्वोत्तम प्रथाओं का पालन करना आपकी कोडिंग को अधिक कुशल, पठनीय और त्रुटि-मुक्त बना सकता है। इस सेक्शन में, हम पाइथन में लूप्स का उपयोग करते समय ध्यान में रखने योग्य कुछ महत्वपूर्ण टिप्स और ट्रिक्स पर चर्चा करेंगे।

1. सही लूप का चयन करें (Choose the Right Loop)

जब आपको किसी अनुक्रम (sequence) के माध्यम से इटरेट करना हो, तो for लूप का उपयोग करें।
जब आपको शर्त के सत्य होने तक कोड का एक ब्लॉक बार-बार निष्पादित करना हो, तो while लूप का उपयोग करें।

2. अनंत लूप्स से बचें (Avoid Infinite Loops)

while लूप का उपयोग करते समय सुनिश्चित करें कि आपकी शर्त अंततः असत्य हो जाए, ताकि लूप समाप्त हो सके। अन्यथा, आपका लूप अनंत (infinite) लूप बन सकता है।

# अनंत लूप का उदाहरण (Example of Infinite Loop)
# while True:
#     print("यह एक अनंत लूप है।")

3. उचित इंडेंटेशन का उपयोग करें (Use Proper Indentation)

पाइथन में इंडेंटेशन बहुत महत्वपूर्ण है। यह कोड ब्लॉक्स को पहचानने में मदद करता है। लूप्स और अन्य कोड ब्लॉक्स को सही ढंग से इंडेंट करें।

for i in range(5):
    print(i)  # सही इंडेंटेशन
    # print(i) गलत इंडेंटेशन

4. ब्रेक और कंटिन्यू का उपयोग समझदारी से करें (Use Break and Continue Wisely)

break और continue स्टेटमेंट्स का उपयोग करते समय सावधान रहें। ये स्टेटमेंट्स लूप के फ्लो को प्रभावित करते हैं और कभी-कभी कोड को समझने में मुश्किल बना सकते हैं।

for i in range(5):
    if i == 3:
        break
    print(i)
# आउटपुट: 0, 1, 2

for i in range(5):
    if i == 3:
        continue
    print(i)
# आउटपुट: 0, 1, 2, 4

5. लूप्स को अनावश्यक रूप से लंबा न करें (Avoid Unnecessarily Long Loops)

लूप्स को जितना संभव हो उतना संक्षिप्त और कुशल रखें। यदि संभव हो, तो लूप के अंदर किए जाने वाले कार्यों को फंक्शंस में विभाजित करें।

# लंबा लूप (Long Loop)
for i in range(1000):
    # लंबी गणना (Lengthy Calculation)
    pass

# संक्षिप्त लूप (Short Loop)
def lengthy_calculation(i):
    # लंबी गणना (Lengthy Calculation)
    pass

for i in range(1000):
    lengthy_calculation(i)

6. सूची समझ (List Comprehensions) का उपयोग करें (Use List Comprehensions)

जब संभव हो, तो सूची समझ (list comprehensions) का उपयोग करें। ये संक्षिप्त और कुशल होती हैं और कोड को अधिक पठनीय बनाती हैं।

# सामान्य लूप
squares = []
for x in range(10):
    squares.append(x ** 2)

# सूची समझ (List Comprehension)
squares = [x ** 2 for x in range(10)]

7. लूप्स में अनावश्यक गणनाओं से बचें (Avoid Unnecessary Calculations in Loops)

लूप्स के अंदर अनावश्यक गणनाओं से बचें। यदि संभव हो, तो गणनाओं को लूप के बाहर करें और परिणामों को लूप के अंदर उपयोग करें।

# अनावश्यक गणना (Unnecessary Calculation)
for i in range(1000):
    result = some_expensive_function(i)
    print(result)

# पूर्व-गणना (Pre-computation)
precomputed_results = [some_expensive_function(i) for i in range(1000)]
for result in precomputed_results:
    print(result)

8. टिप्पणी (Comments) का उपयोग करें (Use Comments)

लूप्स और जटिल कोड ब्लॉक्स के लिए स्पष्ट और संक्षिप्त टिप्पणियाँ लिखें। यह कोड को समझने और बनाए रखने में मदद करता है।

# 1 से 10 तक की संख्याओं का योग
sum = 0
for i in range(1, 11):
    sum += i
print("योग:", sum)

इन टिप्स का पालन करके, आप अपने लूप्स को अधिक कुशल, पठनीय और त्रुटि-मुक्त बना सकते हैं। लूप्स प्रोग्रामिंग का एक महत्वपूर्ण हिस्सा हैं, और इन्हें सही ढंग से उपयोग करना महत्वपूर्ण है।

पाइथन में लूप (Loops in Python)

for लूप (for Loop)

सिंटैक्स (Syntax)

उदाहरण (Examples)

नेस्टेड for लूप्स (Nested for Loops)

for लूप के साथ else (Using else with for Loop)

लूप कंट्रोल स्टेटमेंट्स के साथ for लूप (for Loop with Loop Control Statements)

while लूप (while Loop)

सिंटैक्स (Syntax)

उदाहरण (Examples)

नेस्टेड while लूप्स (Nested while Loops)

while लूप के साथ else (Using else with while Loop)

लूप कंट्रोल स्टेटमेंट्स के साथ while लूप (while Loop with Loop Control Statements)

नेस्टेड लूप्स (Nested Loops)

सिंटैक्स (Syntax)

उदाहरण (Examples)

नेस्टेड लूप्स के साथ ब्रेक और कंटिन्यू स्टेटमेंट्स (Break and Continue Statements with Nested Loops)

नेस्टेड लूप्स के साथ जटिल डेटा संरचनाओं का उपयोग (Using Nested Loops with Complex Data Structures)

लूप्स के साथ फंक्शंस (Loops with Functions)

सिंटैक्स (Syntax)

उदाहरण (Examples)

लूप्स और फंक्शंस के साथ जटिल समस्याओं को हल करना (Solving Complex Problems with Loops and Functions)

लूप्स के लिए उपयोगी टिप्स (Useful Tips for Loops)

1. सही लूप का चयन करें (Choose the Right Loop)

2. अनंत लूप्स से बचें (Avoid Infinite Loops)

3. उचित इंडेंटेशन का उपयोग करें (Use Proper Indentation)

4. ब्रेक और कंटिन्यू का उपयोग समझदारी से करें (Use Break and Continue Wisely)

5. लूप्स को अनावश्यक रूप से लंबा न करें (Avoid Unnecessarily Long Loops)

6. सूची समझ (List Comprehensions) का उपयोग करें (Use List Comprehensions)

7. लूप्स में अनावश्यक गणनाओं से बचें (Avoid Unnecessary Calculations in Loops)

8. टिप्पणी (Comments) का उपयोग करें (Use Comments)

यह भी जानें

पाइथन में फंक्शंस (Functions in Python)

नियमित अभिव्यक्ति (Regular Expressions in Python)

पायथन में ऑपरेटर्स का उपयोग(Using Operators in Python)

उपयोगकर्ता इनपुट और आउटपुट (User Input and Output in Python)

for लूप के साथ `else` (Using `else` with for Loop)

while लूप के साथ `else` (Using `else` with while Loop)