पायथन लूप कंट्रोल में महारत: break, continue, और pass स्टेटमेंट का प्रभावी उपयोग

परिचय

पायथन में for loops और while loops का उपयोग आपको कार्यों को स्वचालित करने और कुशलतापूर्वक दोहराने की अनुमति देता है। ये लूप पायथन में मौलिक संरचनाएं हैं जो आपको अनुक्रमों जैसे सूचियों, टपल्स, और स्ट्रिंग्स पर पुनरावृति करने या किसी स्थिति के आधार पर कोड के ब्लॉक को बार-बार निष्पादित करने में सक्षम बनाती हैं।

हालांकि, ऐसे परिदृश्य होते हैं जहां आपको अपने लूप के प्रवाह पर अधिक नियंत्रण की आवश्यकता होती है। उदाहरण के लिए, आप ऐसी स्थिति का सामना कर सकते हैं जहां आपको समय से पहले लूप से बाहर निकलने, वर्तमान पुनरावृति को छोड़ने, या भविष्य के कोड के लिए प्लेसहोल्डर रखने की आवश्यकता हो। पायथन इन मामलों को संभालने के लिए तीन शक्तिशाली स्टेटमेंट प्रदान करता है: break, continue, और pass।

• break स्टेटमेंट आपको एक विशिष्ट स्थिति पूरी होने पर लूप से पूरी तरह बाहर निकलने की अनुमति देता है, जिससे लूप निष्पादन प्रभावी रूप से रुक जाता है।
• continue स्टेटमेंट आपको लूप के अंदर वर्तमान पुनरावृति के लिए शेष कोड को छोड़कर अगली पुनरावृति पर जाने देता है।
• pass स्टेटमेंट एक नल ऑपरेशन है; इसका उपयोग लूप, फ़ंक्शन, क्लास, या कंडीशनल में प्लेसहोल्डर के रूप में किया जाता है जहां सिंटैक्टिक रूप से कोड आवश्यक है लेकिन आपके पास निष्पादित करने के लिए कुछ नहीं है।

इन स्टेटमेंट को समझना और उपयोग करना लूप कंट्रोल फ्लो को प्रबंधित करने की आपकी क्षमता को महत्वपूर्ण रूप से बढ़ा सकता है, जिससे आपका कोड अधिक कुशल और पढ़ने में आसान बनता है। यह लेख पायथन के break, continue, और pass स्टेटमेंट को लूप के भीतर प्रभावी ढंग से फ्लो कंट्रोल के लिए उपयोग करने के लिए एक व्यापक मार्गदर्शिका प्रदान करता है। यह व्यावहारिक कोड उदाहरणों और आउटपुट प्रदर्शनों के साथ प्रत्येक स्टेटमेंट के उद्देश्य और व्यवहार की व्याख्या करता है। लेख उन्नत लूप कंट्रोल तकनीकों का भी पता लगाता है, जिसमें बहु-स्तरीय लूप निकास के तरीके शामिल हैं, और क्लीनर पोस्ट-लूप लॉजिक के लिए लूप के साथ कम-ज्ञात else क्लॉज का परिचय देता है। डेटा पार्सिंग, फ़ाइल स्कैनिंग, और मैट्रिक्स ट्रैवर्सल जैसे वास्तविक दुनिया के परिदृश्य शामिल हैं ताकि यह दिखाया जा सके कि ये अवधारणाएं व्यावहारिक पायथन प्रोग्रामिंग में कैसे लागू होती हैं।

क्या आपको पायथन प्रोजेक्ट को तैनात करना है और इसे जल्दी लाइव करना है? डिजिटलओशन ऐप प्लेटफ़ॉर्म देखें और मिनटों में गिटहब से सीधे पायथन प्रोजेक्ट तैनात करें।

मुख्य बातें

• पायथन में break स्टेटमेंट आपको एक विशिष्ट स्थिति पूरी होने पर लूप से तुरंत बाहर निकलने की अनुमति देता है, जो खोज या सत्यापन संचालन के दौरान जल्दी समाप्ति के लिए विशेष रूप से उपयोगी है।
• continue स्टेटमेंट वर्तमान पुनरावृति के शेष भाग को छोड़कर लूप के अगले चक्र पर चला जाता है, जिससे गहरे नेस्टेड कंडीशनल से बचने और लूप स्पष्टता में सुधार करने में मदद मिलती है।
• pass स्टेटमेंट एक सिंटैक्टिक प्लेसहोल्डर है जो कोई कार्रवाई नहीं करता, आमतौर पर तब उपयोग किया जाता है जब कोड का एक ब्लॉक सिंटैक्टिक रूप से आवश्यक होता है लेकिन लॉजिक अभी तक लागू नहीं किया गया है।
• चूंकि पायथन में कई नेस्टेड लूप से बाहर निकलने के लिए मूल समर्थन नहीं है, एक फ्लैग वेरिएबल का उपयोग करके स्थिति को ट्रैक करना और बाहरी लूप व्यवहार को नियंत्रित करना एक व्यावहारिक समाधान है।
• लूप लॉजिक को फ़ंक्शन में एनकैप्सुलेट करना और return का उपयोग करना आपको पुनरावृत्ति के कई स्तरों से साफ़ तरीके से बाहर निकलने की अनुमति देता है और कोड मॉड्यूलरिटी और रखरखाव में सुधार करता है।
• हालांकि अपवादों का उपयोग नेस्टेड लूप से बाहर निकलने के लिए किया जा सकता है, उन्हें वास्तव में असाधारण स्थितियों के लिए आरक्षित किया जाना चाहिए और प्रदर्शन और पठनीयता चिंताओं के कारण नियमित लूप कंट्रोल के लिए उन पर भरोसा नहीं किया जाना चाहिए।
• for और while लूप पर else क्लॉज केवल तभी निष्पादित होता है जब लूप break को हिट किए बिना सामान्य रूप से पूरा होता है, जो इसे स्पष्ट और संक्षिप्त "नहीं मिला" लॉजिक को लागू करने के लिए आदर्श बनाता है।

पूर्वापेक्षाएँ

आपके कंप्यूटर या सर्वर पर पायथन 3 इंस्टॉल और एक प्रोग्रामिंग वातावरण होना चाहिए। यदि आपके पास प्रोग्रामिंग वातावरण सेट नहीं है, तो आप अपने ऑपरेटिंग सिस्टम (उबंटू, सेंटओएस, डेबियन, आदि) के लिए उपयुक्त स्थानीय पायथन प्रोग्रामिंग वातावरण की स्थापना के लिए इंस्टॉलेशन और सेटअप गाइड देख सकते हैं।

Break स्टेटमेंट

पायथन में, break स्टेटमेंट आपको एक बाहरी स्थिति ट्रिगर होने पर लूप से बाहर निकलने की अनुमति देता है। आप break स्टेटमेंट को अपने लूप स्टेटमेंट के तहत कोड ब्लॉक के भीतर रखेंगे, आमतौर पर एक सशर्त if स्टेटमेंट के बाद।

जानकारी: इस ट्यूटोरियल में उदाहरण कोड के साथ चलने के लिए, अपने स्थानीय सिस्टम पर python3 कमांड चलाकर एक पायथन इंटरैक्टिव शेल खोलें। फिर आप >>> प्रॉम्प्ट के बाद उदाहरणों को कॉपी, पेस्ट, या संपादित करके जोड़ सकते हैं।

आइए एक उदाहरण देखते हैं जो for लूप में break स्टेटमेंट का उपयोग करता है:

number = 0
for number in range(10):
    if number == 5:
        break  # यहाँ ब्रेक
    print('Number is ' + str(number))
print('Out of loop')

इस छोटे प्रोग्राम में वेरिएबल number को 0 पर आरंभ किया गया है। फिर, एक for लूप बनाया जाता है जो range(10) द्वारा परिभाषित 0 से 9 तक की संख्याओं के माध्यम से पुनरावृति करता है।

नोट: हालांकि number शुरू में 0 पर सेट है, यह मान for लूप द्वारा तुरंत ओवरराइट हो जाता है, जो प्रत्येक पुनरावृत्ति पर range() से नए मान निर्दिष्ट करता है।

for लूप के भीतर, एक if स्टेटमेंट वह स्थिति प्रस्तुत करता है कि यदि वेरिएबल number पूर्णांक 5 के बराबर है, तो लूप टूट जाएगा। आप पायथन में for() लूप का उपयोग करने पर इस ट्यूटोरियल को देखकर for लूप का उपयोग करने के बारे में अधिक जान सकते हैं।

लूप के अंदर एक print() स्टेटमेंट भी है जो for लूप की प्रत्येक पुनरावृत्ति के साथ निष्पादित होगा जब तक कि लूप न टूट जाए, क्योंकि यह break स्टेटमेंट के बाद है।

आइए for लूप के बाहर एक अंतिम print() स्टेटमेंट रखें ताकि पता चल सके कि आप लूप से बाहर कब हैं।

जब आप इस कोड को चलाते हैं, तो आपको निम्न आउटपुट मिलेगा:

Number is 0
Number is 1
Number is 2
Number is 3
Number is 4
Out of loop

यह दर्शाता है कि एक बार पूर्णांक number के 5 के बराबर मूल्यांकन होने पर, लूप टूट जाता है, क्योंकि प्रोग्राम को break स्टेटमेंट के साथ ऐसा करने के लिए कहा गया है।

break स्टेटमेंट प्रोग्राम को लूप से बाहर निकलने का कारण बनता है।

Continue स्टेटमेंट

continue स्टेटमेंट आपको लूप के उस हिस्से को छोड़ने की अनुमति देता है जहां एक बाहरी स्थिति ट्रिगर होती है, लेकिन लूप के बाकी हिस्से को पूरा करने के लिए आगे बढ़ता है। लूप की वर्तमान पुनरावृत्ति बाधित होगी, लेकिन प्रोग्राम लूप के शीर्ष पर वापस आ जाएगा।

continue स्टेटमेंट लूप स्टेटमेंट के तहत कोड ब्लॉक के भीतर होगा, आमतौर पर एक सशर्त if स्टेटमेंट के बाद।

break स्टेटमेंट अनुभाग में उसी for लूप प्रोग्राम का उपयोग करते हुए, हम break स्टेटमेंट के बजाय continue स्टेटमेंट का उपयोग करेंगे:

number = 0
for number in range(10):
    if number == 5:
        continue  # यहाँ कंटिन्यू
    print('Number is ' + str(number))
print('Out of loop')

break स्टेटमेंट के बजाय continue स्टेटमेंट का उपयोग करने का अंतर यह है कि जब वेरिएबल number का मूल्यांकन 5 के बराबर होता है तो हमारा कोड व्यवधान के बावजूद जारी रहेगा। आइए हमारे आउटपुट की समीक्षा करें:

Number is 0
Number is 1
Number is 2
Number is 3
Number is 4
Number is 6
Number is 7
Number is 8
Number is 9
Out of loop

यहां, आउटपुट में Number is 5 कभी नहीं होता, लेकिन लूप उस बिंदु के बाद 6-9 संख्याओं के लिए लाइनें प्रिंट करना जारी रखता है और फिर लूप छोड़ देता है।

आप continue स्टेटमेंट का उपयोग गहरे नेस्टेड कंडीशनल कोड से बचने या उन मामलों को अस्वीकार करके लूप को अनुकूलित करने के लिए कर सकते हैं जो अक्सर होते हैं जिन्हें आप अस्वीकार करना चाहते हैं।

continue स्टेटमेंट प्रोग्राम को लूप के भीतर आने वाले कुछ कारकों को छोड़ने लेकिन फिर लूप के बाकी हिस्से के माध्यम से जारी रखने का कारण बनता है।

Pass स्टेटमेंट

जब एक बाहरी स्थिति ट्रिगर होती है, तो pass स्टेटमेंट आपको पायथन की सिंटैक्टिक आवश्यकता को कोड ब्लॉक के लिए पूरा करने की अनुमति देता है बिना कोई ऑपरेशन किए; सभी कोड को पढ़ना जारी रहेगा जब तक कि break या अन्य स्टेटमेंट न हो।

अन्य स्टेटमेंट की तरह, pass स्टेटमेंट लूप स्टेटमेंट के तहत कोड ब्लॉक के भीतर होगा, आमतौर पर एक सशर्त if स्टेटमेंट के बाद।

ऊपर दिए गए कोड ब्लॉक का उपयोग करते हुए, आइए break या continue स्टेटमेंट को pass स्टेटमेंट से बदलें:

number = 0
for number in range(10):
    if number == 5:
        pass  # यहाँ पास
    print('Number is ' + str(number))
print('Out of loop')

if कंडीशनल स्टेटमेंट के बाद, pass स्टेटमेंट प्रोग्राम को लूप चलाते रहने और यह अनदेखा करने के लिए कहता है कि वेरिएबल number अपनी पुनरावृत्ति में से एक के दौरान 5 के बराबर मूल्यांकन करता है।

आप प्रोग्राम चलाएंगे और निम्न आउटपुट प्राप्त करेंगे:

Number is 0
Number is 1
Number is 2
Number is 3
Number is 4
Number is 5
Number is 6
Number is 7
Number is 8
Number is 9
Out of loop

इस प्रोग्राम में pass स्टेटमेंट का उपयोग करके, आप देखते हैं कि प्रोग्राम ठीक वैसे ही चलता है जैसे कि प्रोग्राम में कोई कंडीशनल स्टेटमेंट नहीं थे। pass स्टेटमेंट प्रोग्राम को उस स्थिति को अनदेखा करने और प्रोग्राम को हमेशा की तरह चलाना जारी रखने के लिए कहता है।

pass स्टेटमेंट न्यूनतम क्लास बना सकता है, या नए कोड पर काम करते समय और विवरणों को लागू करने से पहले एल्गोरिदमिक स्तर पर सोचते समय प्लेसहोल्डर के रूप में कार्य कर सकता है।

प्रदर्शन निहितार्थ: अपवाद बनाम फ्लैग बनाम फ़ंक्शन

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

आइए प्रत्येक दृष्टिकोण को उदाहरणों के साथ देखें और चर्चा करें कि एक का उपयोग दूसरे पर कब करना सबसे अच्छा है।

लूप से बाहर निकलने के लिए अपवादों का उपयोग

पायथन में, गहरे नेस्टेड लूप से बाहर निकलने के लिए जानबूझकर अपवाद उठाए जा सकते हैं। हालांकि यह विधि काम करती है, यह नियमित कंट्रोल फ्लो के लिए सबसे कुशल नहीं है।

class ExitLoop(Exception):
    pass

try:
    for i in range(5):
        for j in range(5):
            if i == 2 and j == 3:
                raise ExitLoop()
            print(f"i={i}, j={j}")
except ExitLoop:
    print("Exited nested loops using an exception.")

i=0, j=0
i=0, j=1
i=0, j=2
i=0, j=3
i=0, j=4
i=1, j=0
i=1, j=1
i=1, j=2
i=1, j=3
i=1, j=4
i=2, j=0
i=2, j=1
i=2, j=2
Exited nested loops using an exception.

नोट: अपवाद उठाना और पकड़ना पायथन में अपेक्षाकृत धीमा है क्योंकि इसके लिए स्टैक अनवाइंडिंग और ऑब्जेक्ट निर्माण की आवश्यकता होती है। अपवाद वास्तव में असाधारण स्थितियों के लिए आदर्श हैं, नियमित कंट्रोल लॉजिक के लिए नहीं।

नेस्टेड लूप से बाहर निकलने के लिए फ्लैग का उपयोग

फ्लैग नेस्टेड लूप से बाहर निकलने का एक सरल और पठनीय तरीका है। वे एक वेरिएबल (आमतौर पर बूलियन) को सेट करके काम करते हैं जब एक स्थिति पूरी होती है, फिर बाहरी लूप में उस फ्लैग की जांच करते हैं।

found = False
for i in range(5):
    for j in range(5):
        if i == 2 and j == 3:
            found = True
            break
        print(f"i={i}, j={j}")
    if found:
        break
print("Exited nested loops using a flag.")

i=0, j=0
i=0, j=1
i=0, j=2
i=0, j=3
i=0, j=4
i=1, j=0
i=1, j=1
i=1, j=2
i=1, j=3
i=1, j=4
i=2, j=0
i=2, j=1
i=2, j=2
Exited nested loops using a flag.

फ्लैग लूप कंट्रोल के लिए अपवादों की तुलना में अधिक कुशल हैं और एक अच्छा विकल्प हैं जब:

• आपको कई लूप से बाहर निकलने की आवश्यकता है।
• आप साफ, पठनीय कोड चाहते हैं।
• आप अतिरिक्त फ़ंक्शन या क्लास परिभाषाएं पेश नहीं करना चाहते।

return वाले फ़ंक्शन का उपयोग करके जल्दी बाहर निकलना

अपने लूप लॉजिक को फ़ंक्शन में लपेटना और बाहर निकलने के लिए return का उपयोग करना एक शर्त पूरी होने पर निष्पादन रोकने का एक पायथनिक और कुशल तरीका है।

def search():
    for i in range(5):
        for j in range(5):
            if i == 2 and j == 3:
                print("Condition met. Exiting function.")
                return
            print(f"i={i}, j={j}")

search()

i=0, j=0
i=0, j=1
i=0, j=2
i=0, j=3
i=0, j=4
i=1, j=0
i=1, j=1
i=1, j=2
i=1, j=3
i=1, j=4
i=2, j=0
i=2, j=1
i=2, j=2
Condition met. Exiting function.

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

• आप लूप को फ़ंक्शन के अंदर एनकैप्सुलेट कर सकते हैं।
• आप कम साइड इफेक्ट के साथ साफ निकास चाहते हैं।
• आप लॉजिक को पुन: उपयोग करने या स्वतंत्र रूप से परीक्षण करने की योजना बनाते हैं।

निम्न तालिका पायथन में लूप से बाहर निकलने के प्रत्येक तरीके के लिए पठनीयता, प्रदर्शन, और आदर्श उपयोग के मामलों की तुलना करती है, जिससे आप अपने परिदृश्य के लिए सबसे प्रभावी दृष्टिकोण चुन सकते हैं।

अधिकांश स्थितियों के लिए जहां आपको नेस्टेड लूप या जटिल शर्तों से बाहर निकलने की आवश्यकता होती है, उनकी स्पष्टता और प्रदर्शन के कारण फ़ंक्शन या फ्लैग पसंदीदा तरीके हैं। अपवादों का उपयोग करने से बचें जब तक कि वास्तविक त्रुटियों या अप्रत्याशित स्थितियों को संभाल न रहे हों।

क्लीनर निकास के लिए लूप के साथ else क्लॉज का उपयोग

पायथन for और while दोनों लूप के साथ else क्लॉज के उपयोग की अनुमति देता है। हालांकि यह सुविधा पहली नज़र में असामान्य लग सकती है, यह क्लीनर और अधिक पठनीय कोड का कारण बन सकती है, खासकर जब break जैसे कंट्रोल फ्लो स्टेटमेंट के साथ संयुक्त।

लूप else व्यवहार को समझना

लूप से जुड़ा else ब्लॉक केवल तभी निष्पादित होता है जब लूप break स्टेटमेंट का सामना किए बिना पूरा होता है। यह खोज संचालन के लिए विशेष रूप से उपयोगी है, जहां आप एक अनुक्रम पर पुनरावृति कर रहे हैं और यदि कोई स्थिति पूरी होती है तो एक कार्रवाई करते हैं या यदि नहीं तो वैकल्पिक कार्रवाई करते हैं।

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

उदाहरण: सूची में मान खोजना

आइए एक सरल उपयोग केस पर विचार करें: सूची में किसी आइटम की खोज।

items = ["apple", "banana", "cherry", "date"]
for item in items:
    if item == "cherry":
        print("Found cherry!")
        break
else:
    print("Cherry not found.")

यह कैसे काम करता है:

• for लूप सूची पर पुनरावृति करता है।
• यदि "cherry" मिल जाता है, तो break स्टेटमेंट लूप को तुरंत रोक देता है।
• यदि लूप break का सामना किए बिना पूरा होता है, तो else ब्लॉक चलता है।

आउटपुट:

Found cherry!

यदि हम खोज शब्द को सूची में नहीं मौजूद किसी चीज़ में बदलते हैं:

for item in items:
    if item == "fig":
        print("Found fig!")
        break
else:
    print("Fig not found.")

आउटपुट:

Fig not found.

यह दृष्टिकोण बाहरी फ्लैग वेरिएबल की आवश्यकता को समाप्त करता है ताकि यह निर्धारित किया जा सके कि आइटम मिला था या नहीं।

else को लूप के साथ क्यों उपयोग करें?

else क्लॉज के बिना, आप आमतौर पर एक फ्लैग का उपयोग करके समान तर्क का प्रबंधन करेंगे जो अनावश्यक रूप से कंट्रोल फ्लो को जटिल बना सकता है:

found = False
for item in items:
    if item == "cherry":
        print("Found cherry!")
        found = True
        break
if not found:
    print("Cherry not found.")

हालांकि यह काम करता है, इसके लिए एक अतिरिक्त वेरिएबल (found) को पेश करने और प्रबंधित करने की आवश्यकता होती है। else क्लॉज का उपयोग पूरे लूप निर्माण के भीतर तर्क को एनकैप्सुलेट करने में मदद करता है, जिससे सरल और अधिक केंद्रित कोड बनता है, विशेष रूप से छोटी खोजों या सशर्त पुनरावृत्ति में।

व्यावहारिक उपयोग केस: कीवर्ड के लिए फ़ाइल स्कैन करना

मान लीजिए आप एक फ़ाइल को लाइन दर लाइन पढ़ रहे हैं और जांचना चाहते हैं कि क्या उसमें कोई विशिष्ट कीवर्ड है। for-else संरचना का उपयोग करने से आप दोनों परिणामों को साफ़ तरीके से संभाल सकते हैं:

with open("example.txt") as f:
    for line in f:
        if "error" in line:
            print("Error found in file.")
            break
    else:
        print("No errors detected.")

यहां:

• लूप प्रत्येक लाइन को स्कैन करता है।
• यदि कीवर्ड "error" मिल जाता है, तो यह एक संदेश प्रिंट करता है और लूप से जल्दी बाहर निकल जाता है।
• यदि ऐसी कोई लाइन मौजूद नहीं है, तो लूप समाप्त होने के बाद else क्लॉज निष्पादित होता है।

यह पैटर्न फ़ाइल स्कैनिंग, लॉग विश्लेषण, या किसी भी खोज-थ्रू-अनुक्रम परिदृश्य में विशेष रूप से उपयोगी हो सकता है।

while लूप के साथ else का उपयोग

else क्लॉज while लूप के साथ उसी तरह काम करता है। यह केवल तभी चलता है जब लूप की स्थिति बिना break का सामना किए झूठी हो जाती है।

count = 0
while count < 5:
    if count == 3:
        print("Condition met. Exiting early.")
        break
    count += 1
else:
    print("Loop completed without meeting condition.")

इस उदाहरण में:

• यदि count 3 तक पहुंच जाता है, तो लूप break के माध्यम से बाहर निकलता है, और else क्लॉज छोड़ दिया जाता है।
• यदि लूप break को ट्रिगर किए बिना पूरी तरह से चलता है, तो else ब्लॉक निष्पादित होता है।

यह तब मददगार हो सकता है जब आप पता लगाना चाहते हैं कि लूप ने अपनी पुनरावृत्ति की पूरी श्रृंखला पूरी की या किसी विशिष्ट स्थिति के कारण समय से पहले समाप्त हो गया।

निम्न तालिका सारांशित करती है कि लूप से जुड़ा else क्लॉज कब निष्पादित होगा, इस पर निर्भर करता है कि लूप कैसे निकाला गया है।

लूप के साथ else क्लॉज कंडीशनल या अपवाद का प्रतिस्थापन नहीं है, लेकिन यह बाहरी स्टेट प्रबंधन के बिना "नहीं मिला" मामलों या पोस्ट-इटरेशन लॉजिक को संभालने का एक साफ और पायथनिक तरीका है।

बहु-स्तरीय लूप ब्रेक के लिए वास्तविक दुनिया के परिदृश्य

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

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

आइए कई व्यावहारिक उदाहरणों के माध्यम से चलते हैं ताकि यह समझा जा सके कि बहु-स्तरीय लूप ब्रेक का प्रभावी ढंग से उपयोग कब और कैसे करना है।

संरचित डेटा पार्स करना (जैसे CSV या JSON)

मान लीजिए आप सारणीबद्ध डेटा पार्स कर रहे हैं (जैसे CSV फ़ाइल से पंक्तियों की सूची), और आप एक विशिष्ट मान ढूंढना चाहते हैं। एक बार जब आप इसे ढूंढ लेते हैं, तो स्कैन जारी रखने की कोई आवश्यकता नहीं है।

यहां एक 2D सूची है जो एक साधारण डेटासेट की पंक्तियों और स्तंभों की नकल करती है:

data = [
    ["id", "name", "status"],
    ["001", "Alice", "active"],
    ["002", "Bob", "inactive"],
    ["003", "Carol", "active"]
]

मान लीजिए आप डेटासेट में "Bob" मौजूद है या नहीं ढूंढना चाहते हैं:

target = "Bob"
found = False
for row in data:
    for item in row:
        if item == target:
            print(f"Found target '{target}' in row: {row}")
            found = True
            break  # आंतरिक लूप से बाहर निकलें
    if found:
        break  # बाहरी लूप से बाहर निकलें

Found target 'Bob' in row: ['002', 'Bob', 'inactive']

यह क्यों काम करता है:

• आंतरिक लूप प्रत्येक आइटम की जांच करता है।
• जब यह लक्ष्य ढूंढता है, तो यह found फ्लैग को True पर सेट करता है और आंतरिक लूप से बाहर निकल जाता है।
• बाहरी लूप फ्लैग की जांच करता है और भी बाहर निकल जाता है।

यह तकनीक आवश्यकता से अधिक डेटा स्कैन करने से बचाती है, बड़े डेटासेट के लिए प्रदर्शन में सुधार करती है।

नेस्टेड निर्देशिकाओं में फ़ाइलें खोजना

वास्तविक दुनिया के अनुप्रयोगों जैसे लॉग विश्लेषण, सामग्री खोज, या सुरक्षा ऑडिट पर काम करते समय, आपको कई नेस्टेड निर्देशिकाओं में फैली सैकड़ों टेक्स्ट फ़ाइलों के माध्यम से खोज करने की आवश्यकता हो सकती है। लक्ष्य अक्सर एक विशिष्ट कीवर्ड ढूंढना होता है, जैसे API कुंजी, पासवर्ड, या उपयोगकर्ता आईडी। एक बार कीवर्ड किसी भी फ़ाइल में मिल जाने पर, खोज को समय और संसाधन बचाने के लिए तुरंत समाप्त कर देना चाहिए।

पायथन एक बिल्ट-इन फ़ंक्शन os.walk() प्रदान करता है जो आपको रूट निर्देशिका के भीतर सभी फ़ाइलों और फ़ोल्डर्स पर पुनरावृति करने की अनुमति देता है, जिसका अर्थ है कि यह सबडायरेक्टरी में भी जाएगा।

आइए एक उदाहरण देखें। आपको एक निर्देशिका में सभी .txt फ़ाइलों को पुनरावर्ती रूप से स्कैन करने, प्रत्येक लाइन को कीवर्ड के लिए खोजने, और कीवर्ड मिलने पर तुरंत रुकने और फ़ाइल नाम रिपोर्ट करने की आवश्यकता है।

import os

def search_file(root_dir, keyword):
    for folder, subfolders, files in os.walk(root_dir):
        for file in files:
            if file.endswith(".txt"):
                with open(os.path.join(folder, file)) as f:
                    for line in f:
                        if keyword in line:
                            print(f"Found '{keyword}' in {file}")
                            return  # फ़ंक्शन से रिटर्न करके सभी लूप से बाहर निकलें
    print("Keyword not found.")

आप फ़ंक्शन को इस तरह कॉल कर सकते हैं:

search_file("./documents", "password123")

यहां फ़ंक्शन का उपयोग क्यों करें:

• return फ़ंक्शन से तुरंत बाहर निकलता है, जो नेस्टेड लूप शामिल होने पर उपयोगी होता है।
• कोड के कई स्तरों पर फ्लैग का उपयोग करने से अधिक साफ़।
• आदर्श जब लॉजिक को मॉड्यूलर किया जा सकता है।

ग्रिड या मैट्रिक्स खोज (जैसे खेलों या पाथफाइंडिंग में)

2D ग्रिड (सूचियों की सूची) के साथ काम करने की कल्पना करें, जैसे गेम मैप या सीटिंग चार्ट, और पहली बाधा या भरी हुई सीट ढूंढने की आवश्यकता है। आप ग्रिड को स्कैन करना बंद करना चाहते हैं जैसे ही पहली बाधा मिल जाती है, बजाय अनावश्यक रूप से हर शेष सेल की जांच करने के।

आइए ग्रिड को परिभाषित करें जहां 0 खाली स्थान दर्शाता है, 1 बाधा दर्शाता है:

grid = [
    [0, 0, 0, 1],
    [0, 1, 0, 0],
    [0, 0, 0, 0],
]

मान लीजिए आपका कार्य पहली बाधा (1) को ढूंढना और फिर रुकना है।

found = False
for row_index, row in enumerate(grid):
    for col_index, cell in enumerate(row):
        if cell == 1:
            print(f"Obstacle found at ({row_index}, {col_index})")
            found = True
            break  # आंतरिक लूप से बाहर निकलें
    if found:
        break  # बाहरी लूप से बाहर निकलें

Obstacle found at (0, 3)

क्या हो रहा है:

• प्रत्येक सेल की जांच नेस्टेड for लूप का उपयोग करके की जाती है।
• पहला 1 मिलने पर found फ्लैग का उपयोग करके दोनों लूप से ब्रेक ट्रिगर होता है।

इस प्रकार की खोज भूलभुलैया-समाधान, मैट्रिक्स स्कैनिंग, या माइनस्वीपर जैसे खेलों में आम है।

नेस्टेड डेटा फ़ील्ड को मान्य करना

वास्तविक दुनिया के अनुप्रयोगों में, विशेष रूप से फॉर्म हैंडलिंग, API प्रोसेसिंग, या उपयोगकर्ता प्रबंधन प्रणालियों में, आप अक्सर डिक्शनरी की सूचियों से निपटते हैं, प्रत्येक डिक्शनरी कई फ़ील्ड के साथ एक रिकॉर्ड का प्रतिनिधित्व करती है।

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

आइए एक उदाहरण देखें। हमारे पास उपयोगकर्ताओं की एक सूची है जहां प्रत्येक उपयोगकर्ता के पास name और email होना चाहिए; हमारा लक्ष्य सभी उपयोगकर्ताओं को स्कैन करना, उनके प्रत्येक फ़ील्ड की जांच करना, और किसी भी फ़ील्ड के गायब होते ही प्रोसेसिंग तुरंत रोक देना है, यह रिपोर्ट करते हुए कि कौन सा फ़ील्ड गायब है और किस उपयोगकर्ता के लिए।

निम्न नमूना इनपुट पर विचार करें:

users = [
    {"name": "Alice", "email": "alice@example.com"},
    {"name": "Bob", "email": ""},
    {"name": "Carol", "email": "carol@example.com"},
]

यहां, बॉब का ईमेल फ़ील्ड खाली है। हम इसे पकड़ना चाहते हैं।

invalid = False
for user in users:
    for key, value in user.items():
        if not value:
            print(f"Invalid entry: Missing {key} for user {user['name']}")
            invalid = True
            break
    if invalid:
        break

Invalid entry: Missing email for user Bob

प्रोग्राम सही ढंग से पहचानता है कि बॉब का ईमेल गायब है और आगे की जांच रोक देता है; कैरल का मूल्यांकन कभी नहीं किया जाता, क्योंकि हम लूप से जल्दी बाहर निकल गए।

यह पैटर्न क्यों उपयोगी है:

• आप एक बार त्रुटि का पता चलने के बाद अनावश्यक जांच को रोकते हैं।
• फेल-फास्ट व्यवहार को लागू करने में मदद करता है, जहां सिस्टम जल्दी रुक जाता है अगर कुछ गलत है।

बहु-स्तरीय ब्रेक का उपयोग कब करना चाहिए?

बहु-स्तरीय ब्रेक का उपयोग तब करें जब:

• लूप जारी रखने से समय या संसाधन बर्बाद होंगे।
• आप पहले ही ढूंढ चुके हैं जो आप खोज रहे हैं।
• जल्दी निकास तर्क को समझना और बनाए रखना आसान बनाते हैं।

अपनी विधि बुद्धिमानी से चुनें:

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

1. पायथन में pass, continue, और break का उपयोग कैसे करें?

• pass: pass स्टेटमेंट कुछ नहीं करता; इसका उपयोग प्लेसहोल्डर के रूप में किया जाता है जब एक स्टेटमेंट सिंटैक्टिक रूप से आवश्यक होता है लेकिन किसी कार्रवाई की आवश्यकता नहीं होती। उदाहरण के लिए:

  for i in range(5):
      if i == 3:
          pass  # भविष्य के कोड के लिए प्लेसहोल्डर
      print(i)

• continue: continue स्टेटमेंट वर्तमान पुनरावृत्ति में शेष कोड को छोड़ देता है और लूप की अगली पुनरावृत्ति पर चला जाता है। उदाहरण:

  for i in range(5):
      if i == 3:
          continue  # i == 3 होने पर वर्तमान पुनरावृत्ति छोड़ें
      print(i)

• break: break स्टेटमेंट पुनरावृत्ति स्थिति की परवाह किए बिना लूप से तुरंत बाहर निकल जाता है। उदाहरण:

  for i in range(5):
      if i == 3:
          break  # i == 3 होने पर लूप से बाहर निकलें
      print(i)

2. for लूप में break और continue स्टेटमेंट का उपयोग कैसे कर सकते हैं?

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

for i in range(10):
    if i == 5:
        break  # i == 5 होने पर लूप से बाहर निकलें
    print(i)

continue स्टेटमेंट वर्तमान पुनरावृत्ति के शेष भाग को छोड़ देता है और अगली पुनरावृत्ति पर चला जाता है। उदाहरण:

for i in range(10):
    if i % 2 == 0:
        continue  # सम संख्याओं को छोड़ें
    print(i)  # केवल विषम संख्याएं प्रिंट करता है

3. क्या आप break के बाद लूप फिर से शुरू कर सकते हैं?

एक बार break स्टेटमेंट निष्पादित हो जाने पर, लूप समाप्त हो जाता है, और लूप के बाद का कोड निष्पादित होता है। यदि आप ब्रेक के बाद लूप "जारी रखना" चाहते हैं, तो आपको लूप को पुनः आरंभ करने की आवश्यकता है।

उदाहरण के लिए:

for i in range(3):  # पहला लूप
    if i == 1:
        break  # i == 1 होने पर लूप से बाहर निकलें
    print(f"First loop iteration: {i}")

# लूप को पुनः आरंभ करना
for i in range(3, 6):  # दूसरा लूप
    print(f"Second loop iteration: {i}")

4. मैं अपने पायथन फॉर लूप में break स्टेटमेंट का उपयोग कैसे कर सकता हूं?

break स्टेटमेंट का उपयोग फॉर लूप में इसे समाप्त करने के लिए सीधा है जब एक विशिष्ट स्थिति पूरी होती है:

for i in range(5):
    print(f"Checking value: {i}")
    if i == 2:
        print("Condition met. Breaking out of the loop.")
        break  # लूप से तुरंत बाहर निकलें
print("Loop ended.")

5. पायथन में लूप कैसे कोड करें?

पायथन में, लूप for या while का उपयोग करके लिखे जा सकते हैं। उदाहरण:

for लूप का उपयोग:

for i in range(5):
    print(i)  # 0 से 4 तक संख्याएं प्रिंट करता है

while लूप का उपयोग:

count = 0
while count < 5:
    print(count)  # 0 से 4 तक संख्याएं प्रिंट करता है
    count += 1

पायथन में for लूप और while लूप का उपयोग करने के बारे में अधिक जानने के लिए, आप नीचे दिए गए ट्यूटोरियल देख सकते हैं:

• पायथन में for लूप का उपयोग
• पायथन 3 में while लूप का निर्माण

6. पायथन for लूप में pass क्या करता है?

pass स्टेटमेंट प्लेसहोल्डर के रूप में कार्य करता है और कोई कार्रवाई नहीं करता। इसका उपयोग अक्सर तब किया जाता है जब कोड का एक ब्लॉक सिंटैक्टिक रूप से आवश्यक होता है लेकिन अभी तक लागू नहीं किया गया है:

for i in range(5):
    if i == 3:
        pass  # प्लेसहोल्डर
    print(i)

0
1
2
3
4

7. क्या पायथन break सभी लूप से बाहर निकलता है?

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

for i in range(3):
    for j in range(3):
        if i == 1 and j == 1:
            break  # आंतरिक लूप से बाहर निकलता है
        print(f"i={i}, j={j}")

i=0, j=0
i=0, j=1
i=0, j=2
i=1, j=0
i=2, j=0
i=2, j=1
i=2, j=2

सभी लूप से बाहर निकलने के लिए, आप फ्लैग का उपयोग कर सकते हैं या लूप को फ़ंक्शन में लपेटकर return का उपयोग कर सकते हैं:

# फ्लैग का उपयोग
flag = False
for i in range(3):
    for j in range(3):
        if i == 1 and j == 1:
            flag = True
            break
        print(f"i={i}, j={j}")
    if flag:
        break

# फ़ंक्शन का उपयोग
def nested_loops():
    for i in range(3):
        for j in range(3):
            if i == 1 and j == 1:
                return  # सभी लूप से बाहर निकलें
            print(f"i={i}, j={j}")

nested_loops()

8. पायथन में कई नेस्टेड लूप से कैसे ब्रेक करें?

पायथन एक साथ कई नेस्टेड लूप से बाहर निकलने के लिए break 2 जैसे बिल्ट-इन सिंटैक्स का समर्थन नहीं करता है। इसके बजाय, आप नेस्टेड लूप से निम्न विधियों में से एक का उपयोग करके बाहर निकल सकते हैं:

1. फ्लैग वेरिएबल का उपयोग करें:

   found = False
   for i in range(3):
       for j in range(3):
           if some_condition(i, j):
               found = True
               break  # आंतरिक लूप तोड़ें
       if found:
           break  # बाहरी लूप तोड़ें

2. लूप को फ़ंक्शन में लपेटें और return का उपयोग करें:

   def search():
       for i in range(3):
           for j in range(3):
               if some_condition(i, j):
                   print("Condition met.")
                   return  # दोनों लूप से बाहर निकलें
   search()

यह फ़ंक्शन-आधारित दृष्टिकोण अक्सर पठनीयता और मॉड्यूलरिटी के लिए पसंद किया जाता है।

9. क्या पायथन लूप में ब्रेक लेवल पैरामीटर है?

नहीं, पायथन में कुछ अन्य भाषाओं (जैसे जावा या PHP) की तरह break लेवल या लेबल-आधारित लूप कंट्रोल नहीं है। पायथन में break स्टेटमेंट हमेशा केवल उस सबसे आंतरिक लूप से बाहर निकलता है जिसमें इसका उपयोग किया जाता है।

नेस्टिंग के कई स्तरों से बाहर निकलने के लिए, आपको उपयोग करने की आवश्यकता है:

• बाहरी लूप को सिग्नल करने के लिए एक फ्लैग।
• return के साथ एक फ़ंक्शन।
• एक अपवाद, हालांकि इसका उपयोग सावधानी से और केवल तभी किया जाना चाहिए जब उचित हो।

10. आंतरिक लूप के अंदर से बाहरी लूप से कैसे बाहर निकलें?

आंतरिक लूप के अंदर से बाहरी लूप से बाहर निकलने के लिए, आप या तो:

1. एक फ्लैग वेरिएबल का उपयोग करें जो आंतरिक लूप के अंदर सेट हो जाता है और बाहरी लूप में जांचा जाता है:

   exit_outer = False
   for i in range(5):
       for j in range(5):
           if i == 2 and j == 3:
               exit_outer = True
               break
       if exit_outer:
           break

2. लूप को फ़ंक्शन में एनकैप्सुलेट करें और क्लीनर और अधिक पायथनिक दृष्टिकोण के लिए return का उपयोग करें:

   def process():
       for i in range(5):
           for j in range(5):
               if i == 2 and j == 3:
                   print("Exiting from nested loop.")
                   return
   process()

11. लूप ब्रेकिंग के लिए अपवादों का उपयोग करना एक अच्छी प्रथा है?

लूप से बाहर निकलने के लिए अपवादों का उपयोग करना तकनीकी रूप से संभव है लेकिन सामान्य कंट्रोल फ्लो के लिए अच्छी प्रथा नहीं माना जाता।

class BreakOut(Exception):
    pass

try:
    for i in range(3):
        for j in range(3):
            if i == 1 and j == 1:
                raise BreakOut()
except BreakOut:
    print("Exited nested loops using exception.")

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

निष्कर्ष

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

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

पायथन लूप और कोर प्रोग्रामिंग अवधारणाओं की अपनी समझ को और बढ़ाने के लिए, इन सहायक ट्यूटोरियल को देखें:

• पायथन for लूप
• शुरुआती के लिए एक व्यावहारिक पायथन ट्यूटोरियल
• पायथन में सूचियों को जोड़ने के 6 तरीके
• पायथन 3 में While Loops का निर्माण कैसे करें
• पायथन 3 और Tweepy लाइब्रेरी के साथ ट्विटरबॉट कैसे बनाएं।

यह कार्य क्रिएटिव कॉमन्स एट्रिब्यूशन-नॉनकमर्शियल-शेयरअलाइक 4.0 इंटरनेशनल लाइसेंस के तहत लाइसेंस प्राप्त है।