Python में लूप्स: कैसे काम करते हैं और कौन-कौन से होते हैं

वे लगभग हर प्रोग्रामिंग भाषा में होते हैं, लेकिन Python में उनके साथ काम करना सबसे सुखद है। जैसे कि बाकी सब कुछ भी।

Python में कोड आमतौर पर क्रमिक रूप से निष्पादित होता है: पहली पंक्ति, फिर दूसरी, तीसरी और इसी तरह। लेकिन कुछ निर्माण इस क्रम को तोड़ने की अनुमति देते हैं, ताकि अधिक जटिल ऑपरेशनों को अंजाम दिया जा सके।

उदाहरण के लिए, लूप्स एक ही कोड ब्लॉक को कई बार निष्पादित करते हैं। Python में दो मुख्य प्रकार के लूप्स होते हैं: while और for। आइए उनके बारे में बात करते हैं।

लूप्स कैसे काम करते हैं

कोई भी लूप दो अनिवार्य तत्वों से बना होता है:

• शर्त — प्रारंभिक पैरामीटर; लूप केवल इसके पूरा होने पर शुरू होगा और जैसे ही शर्त पूरी नहीं होगी, समाप्त हो जाएगा;
• शरीर — वह प्रोग्राम जो लूप के अंदर निष्पादित होता है।

Python सिंटैक्स में, शर्त वाली पंक्ति के अंत में कोलन रखा जाता है, और पूरा शरीर इंडेंटेशन (टैब या चार स्पेस) द्वारा हाइलाइट किया जाता है।

program before loop
condition:
    first line of body
    second line of body
program after loop

Python में while लूप

while — सबसे सरल और समझने में आसान लूप है। इसे प्रारंभिक शर्त के साथ लूप भी कहा जाता है।

x = 1
while x < 5:
    print(x)
    x += 1  # Equivalent to x = x + 1

>>> 1
>>> 2
>>> 3
>>> 4

Python भाषा से इस प्रोग्राम का अनुवाद इस प्रकार किया जा सकता है: “जब तक x पाँच से कम है, x को प्रिंट करें और इसमें एक जोड़ें।”

लेकिन while की सरलता में एक खतरा है: इसे अनंत लूप बनाना आसान है। उदाहरण के लिए, अगर हम ऊपर के कोड से x += 1 हटा दें, तो यह इस प्रकार होगा:

# This code will run indefinitely
x = 1
while x < 5:
    print(x)

यहां x के साथ कुछ नहीं हो रहा है। यह हमेशा एक के बराबर है, इसलिए लूप की शर्त कभी भी पूरी नहीं होगी। तदनुसार, यह कभी समाप्त नहीं होगा।

ऐसी स्थितियों से बचने के लिए, while का उपयोग करते समय ध्यान रखना चाहिए: क्या शर्त कभी पूरी नहीं होगी? इसके अलावा, आप ब्रेक ऑपरेटर का उपयोग कर सकते हैं – इसके बारे में हम बाद में बात करेंगे।

Python में for लूप

for लूप प्रोग्रामर अधिक बार उपयोग करते हैं। इसके लिए हम सीधे रूप में कोई शर्त नहीं, बल्कि कुछ डेटा सरणी सेट करते हैं: सूची, टपल, स्ट्रिंग, शब्दकोश, सीमा, या कोई अन्य इटरेबल ऑब्जेक्ट।

लूप के प्रत्येक इटरेशन पर, प्रोग्राम मानो पूछता है: “क्या ऑब्जेक्ट में ऐसे तत्व बचे हैं, जिन पर मैं नहीं गुजरी हूं?”

मान लीजिए कि हमारे पास संख्याओं की एक सूची है: [14, 101, -7, 0]। हम इसका उपयोग for के साथ कर सकते हैं, ताकि प्रत्येक तत्व को अलग-अलग प्रिंट किया जा सके।

num_list = [14, 101, -7, 0]
for number in num_list:
    print(number)

>>> 14
>>> 101
>>> -7
>>> 0

यहां number चर हर नए लूप के साथ अपडेट होता है। पहले यह पहले तत्व को धारण करता है, फिर दूसरे को, और इसी तरह – जब तक सूची समाप्त नहीं हो जाती।

जैसे किसी भी अन्य चर को, हम number को कुछ भी नाम दे सकते थे। अक्सर अक्षर i, j, और k का उपयोग किया जाता है। यदि हम लूप के भीतर इस चर का उपयोग नहीं करते हैं, तो Python प्रोग्रामर्स इसे अंडरस्कोर _ द्वारा दर्शाते हैं।

range() फ़ंक्शन

जब हमें एक संख्यात्मक सीमा पर for लागू करना होता है, तो इसे एक सीमा द्वारा सेट किया जा सकता है। इसके लिए range() फ़ंक्शन का उपयोग किया जाता है। इसमें एक से तीन तर्क पारित किए जा सकते हैं।

यदि तर्क एक है, तो यह शून्य से तर्क मान से पहले के संख्या तक की सीमा बनाता है।

for i in range(3):
    print(i)

>>> 0
>>> 1
>>> 2

यदि तर्क दो हैं, तो यह पहले तर्क के मान से लेकर दूसरे तर्क के मान से पहले के संख्या तक की सीमा बनाता है।

for i in range(23, 26):
    print(i)

>>> 23
>>> 24
>>> 25

यदि तर्क तीन हैं, तो पहले दो पिछले मामले की तरह काम करते हैं। तीसरा तर्क वह कदम है, जिससे संख्याएँ एक-दूसरे के बाद आती हैं।

for i in range(10, 20, 3):
    print(i)

>>> 10
>>> 13
>>> 16
>>> 19

एक-पंक्ति लूप: लिस्ट कम्प्रीहेंशन

यदि for लूप के शरीर में केवल एक क्रिया की जाती है, तो Python सिंटैक्स उसकी रिकॉर्डिंग को छोटा करने की अनुमति देता है:

i for i in iterable_object

यह सिंटैक्स शुगर है, जो नई कार्यक्षमता नहीं जोड़ता है, लेकिन कोड के स्वरूप को प्रभावित करता है। इस प्रकार, सूची आसानी से और जल्दी उत्पन्न की जा सकती है।

num_list = [i for i in range(1, 11)]
print(num_list)

>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

इस निर्माण में एक अतिरिक्त शर्त भी जोड़ी जा सकती है। हम एक जनरेटर बनाएँगे, जो केवल सम संख्याएँ प्रिंट करेगा। साथ ही प्राप्त सूची के लिए कोई चर नहीं बनाएँगे, बल्कि इसे तुरंत प्रिंट करेंगे।

print([i for i in range(1, 11) if i % 2 == 0])

>>> [2, 4, 6, 8, 10]

if i % 2 == 0 निर्माण का अर्थ है: “यदि i को 2 से विभाजित करने पर शेषफल शून्य है।”

i चर के साथ भी आपरेशन किया जा सकता है। हम पिछले जनरेटर का उपयोग करेंगे, लेकिन अब हम खुद संख्याओं के बजाय उनके वर्ग प्रिंट करेंगे।

print([i ** 2 for i in range(1, 11) if i % 2 == 0])

>>> [4, 16, 36, 64, 100]

मुख्य बात इस दृष्टिकोण में अधिक न खोना है। यदि कोड को पढ़ना और समझना मुश्किल है (उदाहरण के लिए, जब i पर कई फ़ंक्शन और विधियाँ लागू की जाती हैं और इसके अलावा एक जटिल शर्त निर्धारित की जाती है), तो इसे कई पंक्तियों में विभाजित करना बेहतर है। समझदारी संक्षिप्तता से अधिक महत्वपूर्ण है।

लूप को रोकना: break कीवर्ड

कभी-कभी, लूप को जबरन समाप्त करना आवश्यक होता है, भले ही इसकी शर्त अभी भी पूरी हो रही हो। ऐसे मामलों में break कीवर्ड का उपयोग किया जाता है।

हम एक स्ट्रिंग “Hi, loop!” लेंगे और उसके प्रत्येक चर को प्रिंट करेंगे। यदि हम एक कोमा पाते हैं, तो लूप को तुरंत समाप्त करेंगे।

string = 'Hi, loop!'
for i in string:
    if i == ',':
        break
    print(i)

>>> H
>>> i

यदि स्ट्रिंग में कोमा नहीं है, तो लूप इसके प्रत्येक चर पर चलेगा – और केवल इसके बाद समाप्त होगा।

string = 'Hi loop!'
for i in string:
    if i == ',':
        break
    print(i)

>>> H
>>> i
>>>  
>>> l
>>> o
>>> o
>>> p
>>> !

लूप के भाग को छोड़ना: continue कीवर्ड

कभी-कभी लूप का अगला चरण जबरन शुरू करना आवश्यक होता है, लूप के शरीर के कुछ हिस्सों को छोड़ते हुए। ऐसे मामलों के लिए continue कीवर्ड होता है।

हम 1 से 10 तक की संख्याएँ लेंगे और उनमें से केवल वे ही प्रिंट करेंगे, जो न तो 2 से विभाजित होती हैं और न ही 3 से।

for i in range(1, 10):


    if i%2 == 0 or i%3 == 0:
        continue
    print(i)

>>> 1
>>> 5
>>> 7

जैसा कि देखा गया, यदि if शर्त पूरी होती है (अर्थात यदि संख्या 2 या 3 से बिना शेषफल के विभाजित होती है), तो शरीर का बाकी भाग काम नहीं करता – और i प्रिंट नहीं होती।

लूप का अंतिम कार्य: else कीवर्ड

आमतौर पर else कीवर्ड का उपयोग if के साथ किया जाता है, लेकिन इसका और भी उपयोग है। इसका उपयोग while या for के साथ किया जा सकता है। इस स्थिति में else कोड लूप के सभी चरणों के बाद निष्पादित होगा।

यदि लूप break के कारण समय से पहले समाप्त हो जाता है, तो else का भाग निष्पादित नहीं होगा।

हम अपनी स्ट्रिंग “Hi, loop!” को याद करेंगे और उसमें else जोड़ेंगे।

string = 'Hi, loop!'
for i in string:
    if i == ',':
        break
    print(i)
else:
    print('The loop ended without break')

>>> H
>>> i

स्ट्रिंग में एक कोमा था, break ने काम किया – else शर्त निष्पादित नहीं हुई। अब इसे हटाकर देखें कि क्या होता है।

string = 'Hi loop!'
for i in string:
    if i == ',':
        break
    print(i)
else:
    print('The loop ended without break')

>>> H
>>> i
>>>  
>>> l
>>> o
>>> o
>>> p
>>> !
>>> The loop ended without break

लूप ने अपने सभी इटरेशनों को पूरा किया, खुद समाप्त हो गया, और इसलिए else कोड निष्पादित हुआ। यह तब भी काम करेगा जब लूप ने एक भी इटरेशन नहीं किया हो।

while 1 == 0:
    print('This line will never run')
else:
    print('The loop ended without break')

>>> The loop ended without break

अनंत लूप

कभी-कभी अनंत लूप का उपयोग करना एक अच्छा विचार हो सकता है। उदाहरण के लिए, हम एक गेम लिख रहे हैं: इसे तब तक चलना चाहिए जब तक खिलाड़ी बाहर नहीं निकलता। इस स्थिति में, निकास शर्त में break को निर्दिष्ट करना होगा।

ताकि लूप अनंत हो, उसकी शर्त हमेशा पूरी होनी चाहिए। इसे विभिन्न तरीकों से किया जा सकता है।

# Method #1 — "while true"
while True:
    pass  # pass is a placeholder statement that does nothing

यदि while False किया जाए, तो लूप कभी शुरू नहीं होगा।

# Method #2 — "while any nonzero number"
while 1:
    pass
while -4:
    pass
while 2023:
    pass

यदि while 0 किया जाए, तो लूप कभी शुरू नहीं होगा।

# Method #3 — "while non-empty element"
while 'string':
    pass
while [False, 'list', 0]:
    pass

यदि while के बाद खाली तत्व रखा जाए — जैसे कि str() या list(), तो लूप कभी शुरू नहीं होगा।

# Method #4 — Correct equation
while 1 == 1:
    pass
while 0 != 1:
    pass

वैकल्पिक दृष्टिकोण — while के बाद एक चर रखना, जिसमें उपयुक्त शर्त हो। उदाहरण के लिए:

# Method #1
condition = True
while condition:
    pass
# Method #2
condition = 1
while condition:
    pass
# Method #3
condition = 'string'
while condition:
    pass

ऐसे मामलों में, लूप से बाहर निकलने के लिए break ऑपरेटर का उपयोग नहीं किया जा सकता है, बल्कि चर के मान को False, 0, None या किसी भी खाली तत्व में बदल सकता है। लूप आखिरी इटरेशन को समाप्त करेगा और समाप्त हो जाएगा, क्योंकि शर्त अब पूरी नहीं होगी।

इस दृष्टिकोण का उपयोग तब किया जाता है, जब लूप को प्रोग्राम के अन्य स्थानों से समाप्त करना होता है: उदाहरण के लिए, किसी फ़ंक्शन या अंतर्निहित लूप से। एक और अंतर: चूंकि लूप “प्राकृतिक” रूप से समाप्त होता है, बिना break ऑपरेटर के, इसमें else कोड निष्पादित होगा (यदि है)।

condition = True
x = 0
while condition:
    print(x)
    x += 1
    if x == 3:
        condition = False
else:
    print('The loop ended without break')

>>> 0
>>> 1
>>> 2
>>> The loop ended without break

Python में do while का समकक्ष कैसे बनाएं

कुछ प्रोग्रामिंग भाषाओं में एक और प्रकार का लूप होता है — पोस्ट-कंडीशन के साथ। यह हमेशा कम से कम एक इटरेशन करता है और केवल इसके बाद जाँच करता है कि शर्त पूरी हो रही है या नहीं।

Java और C++ में इसे do while निर्माण द्वारा हासिल किया जाता है, लेकिन Python में ऐसा नहीं है। हालांकि, एक समकक्ष बनाया जा सकता है। इसके लिए एक अनंत लूप का उपयोग करना होगा, और उसके शरीर में समाप्ति शर्त को निर्दिष्ट करना होगा।

x = 12
while True:
    x += 1
    print(x)
    if x > 5:
        break

>>> 13

x का मान जो भी हो, ऐसा लूप कम से कम एक इटरेशन करेगा। और यही पोस्ट-कंडीशन है।

Python में नेस्टेड लूप्स

Python में लूप्स को एक-दूसरे के भीतर नेस्ट किया जा सकता है — यानी, एक लूप के शरीर में दूसरे लूप को कॉल कर सकते हैं। प्रोग्राम की लॉजिक इस पर जटिल हो जाती है।

लूप्स को जितना चाहें उतना नेस्ट किया जा सकता है। प्रत्येक नए स्तर की नेस्टिंग के लिए इंडेंटेशन बढ़ाना होगा। यह इस प्रकार दिखता है:

while condition:
    pass
    while inner_condition:
        pass
    pass

हम एक प्रोग्राम लिखेंगे, जो बाहरी और आंतरिक लूप की इटरेशन संख्या को प्रिंट करेगा।

for i in range(3):
    print(f'Outer loop iteration: {i}')
    for j in range(2):
        print(f'Inner loop iteration: {j}')

>>> Outer loop iteration: 0
>>> Inner loop iteration: 0
>>> Inner loop iteration: 1
>>> Outer loop iteration: 1
>>> Inner loop iteration: 0
>>> Inner loop iteration: 1
>>> Outer loop iteration: 2
>>> Inner loop iteration: 0
>>> Inner loop iteration: 1

निष्कर्ष

लूप्स किसी भी Python डेवलपर के मुख्य उपकरणों में से एक हैं। उनकी मदद से, केवल कुछ पंक्तियों के कोड में कई बार दोहराए जाने वाले कार्यों को अंजाम दिया जा सकता है।

• लूप्स शर्त और शरीर से बनते हैं। शरीर में कोड केवल तब तक निष्पादित होता है जब तक शर्त पूरी हो रही हो।
• Python में दो प्रकार के लूप्स होते हैं: while और for। while में शर्त स्पष्ट रूप से दी जाती है। for में संग्रह का प्रत्येक तत्व क्रमशः पारित किया जाता है।
• दोनों प्रकार के लूप्स में विभिन्न ऑपरेटर्स का उपयोग किया जा सकता है: break के लिए, continue के लिए, और else के लिए अंतिम कार्य से पहले लूप से बाहर निकलने के लिए।
• लूप्स को अनंत बनाया जा सकता है (तब प्रोग्राम कभी समाप्त नहीं होगा या केवल शर्त पूरी होने पर समाप्त होगा) और एक-दूसरे में नेस्ट किया जा सकता है।