कैसे अगर एक खंड से बाहर निकलने के लिए

Question

समय से पहले एक ifखंड से बाहर निकलने के लिए किस तरह के तरीके मौजूद हैं ?

ऐसे समय होते हैं जब मैं कोड लिख रहा होता हूं और breakएक ifक्लॉज के अंदर एक स्टेटमेंट डालना चाहता हूं , केवल यह याद रखने के लिए कि उनका उपयोग केवल लूप के लिए किया जा सकता है।

एक उदाहरण के रूप में निम्नलिखित कोड लेते हैं:

if some_condition:
   ...
   if condition_a:
       # do something
       # and then exit the outer if block
   ...
   if condition_b:
       # do something
       # and then exit the outer if block
   # more code here

मैं ऐसा करने का एक तरीका सोच सकता हूं: यदि निकले हुए मामलों में बयानों के तहत निकास के मामलों को मान लिया जाए, तो शेष कोड को एक बड़े ब्लॉक में लपेट दें। उदाहरण:

if some_condition:
   ...
   if condition_a:
       # do something
       # and then exit the outer if block
   else:
       ...
       if condition_b:
           # do something
           # and then exit the outer if block
       else:
           # more code here

इसके साथ समस्या यह है कि अधिक निकास स्थानों का मतलब अधिक घोंसले के शिकार / प्रेरित कोड है।

वैकल्पिक रूप से, मैं अपना कोड लिख सकता हूं कि ifक्लॉस जितना संभव हो उतना छोटा हो और इसके लिए किसी भी निकास की आवश्यकता न हो।

क्या किसी को एक ifखंड से बाहर निकलने का एक अच्छा / बेहतर तरीका पता है ?

यदि कोई अन्य संबद्ध-यदि और कोई धाराएँ हैं, तो मुझे लगता है कि बाहर निकलना उन पर छोड़ देगा।

Comments

अपने दूसरे कोड नमूने के लिए - क्या आप इसके बारे में जानते हैं elif?

— क्रेग मैकक्वीन

"वैकल्पिक रूप से, मैं अपना कोड लिख सकता था कि यदि क्लॉस संभव के रूप में छोटा है और किसी भी निकास की आवश्यकता नहीं है।" - और निश्चित रूप से यह कार्रवाई का सबसे अच्छा कोर्स होगा। :-)

— मिशैल मार्कज़िक

@ क्रेग मैक्वीन: मैं करता हूं, लेकिन मैं कहता हूं कि मैं हालत बयानों के बीच कोड निष्पादित करना चाहता था? जैसे if a: #stuff; #stuff_inbetween; if b: #stuff;inbetween कोड निर्भर करता है not aलेकिन निर्भर नहीं करता है b।

— रोमन

नमस्ते कृपया भूल न जाएं elif stackoverflow.com/a/2069680/7045119

— kerbrose

Answer 1

(यह विधि ifs, एकाधिक नेस्टेड लूप और अन्य निर्माणों के लिए काम करती है जिन्हें आप breakआसानी से नहीं कर सकते हैं।)

अपने स्वयं के फ़ंक्शन में कोड लपेटें। इसके बजाय break, उपयोग करें return।

उदाहरण:

def some_function():
    if condition_a:
        # do something and return early
        ...
        return
    ...
    if condition_b:
        # do something else and return early
        ...
        return
    ...
    return

if outer_condition:
    ...
    some_function()
    ...

Comments

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

— ड्रू डॉर्मन

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

— १४

एक पुराना किस्सा है: "डेनिस रिची ने सभी को बताकर और मोड्यूलरिटी को प्रोत्साहित किया कि फंक्शन कॉल्स वास्तव में सस्ते थे, सी में हर कोई सस्ता था। छोटे कार्यों को लिखना और मॉडरेट करना शुरू कर दिया। वर्षों बाद हमें पता चला कि फंक्शन कॉल पीडीपी -11 पर अभी भी महंगे थे। , और VAX कोड अक्सर CALLS निर्देश में अपने समय का 50% खर्च कर रहा था। डेनिस ने हमसे झूठ बोला था! लेकिन यह बहुत देर हो चुकी थी, हम सभी चौंक गए थे ... "

— विशेषांक

@ephemient: यह मज़ेदार है, कहानी के लिए और क्या है? मैं पूरी बात पढ़ना चाहूंगा।

— रोमन

यह उद्धरण पुस्तक द आर्ट ऑफ यूनिक्स प्रोग्रामिंग के अध्याय 4 से है (ऑनलाइन faqs.org/docs/artu पर )। अगर आपने पहले नहीं किया है, तो आपको वास्तव में पूरी बात पढ़नी चाहिए।

— ५

Answer 2

से गोटो आयात गोटो, लेबल

अगर कुछ
   ...
   अगर हालत_ए:
       # कुछ करो
       # और फिर ब्लॉक होने पर बाहरी से बाहर निकलें
       गोटो
   ...
   अगर हालत_ बी:
       # कुछ करो
       # और फिर ब्लॉक होने पर बाहरी से बाहर निकलें
       गोटो
   # यहाँ और अधिक कोड

लेबल .end

(वास्तव में इस का उपयोग न करें, कृपया)

Comments

+1 क्योंकि यह मज़ेदार है। एक Google खोज ने मुझे बताया कि यह एक अप्रैल फूल का मजाक मॉड्यूल था।

— रोमन

मैं इससे जुड़ा, भी। पहले पर क्लिक करें goto।

— शाम

यह मुझे सभी प्रकार की शाखाओं के साथ विधानसभा कोड की याद दिलाता है :)

— phunehehe

@ कुशल: आह, लिंक पर ध्यान नहीं दिया। लगा कि यह कोड हाइलाइटिंग है। लेकिन अब जब मैं आपके कोड को देखता हूं, तो मुझे कोई वास्तविक हाइलाइटिंग नहीं दिखाई देती है

— रोमन

जब PHP ने गोटो की शुरुआत की तो मैं पायथन php.net/manual/en/control-structures.goto.php की

— मार्क

Answer 3

while some_condition:
   ...
   if condition_a:
       # do something
       break
   ...
   if condition_b:
       # do something
       break
   # more code here
   break

Comments

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

— रोमन

ध्यान दें कि आप मूल रख सकते हैं और पूरी चीज़ को एक में लपेटें while True:। बस breakअंत में एक बयान में रखना सुनिश्चित करें ! डो-कंस्ट्रक्शन वाली भाषाओं के लिए, ऐसा करना अधिक मुहावरेदार है:do { code that can conditionally break out } while (false);

— थॉमस

Answer 4

आप अपवाद के साथ गोटो की कार्यक्षमता का अनुकरण कर सकते हैं:

try:
    # blah, blah ...
    # raise MyFunkyException as soon as you want out
except MyFunkyException:
    pass

डिस्क्लेमर: मेरा मतलब केवल इस तरह से चीजों को करने की संभावना को ध्यान में लाना है , जबकि किसी भी तरह से मैं इसे सामान्य परिस्थितियों के अनुसार उचित नहीं मानता। जैसा कि मैंने प्रश्न पर एक टिप्पणी में उल्लेख किया है, पहली बार में बीजान्टिन की स्थिति से बचने के लिए कोड को संरचित करना अभी तक बेहतर है। :-)

Comments

हाहा, मुझे यह रचनात्मक समाधान पसंद है। हालांकि मैं आपके अस्वीकरण का पालन करूंगा और इस तरह के फंकी कोड का उपयोग नहीं करूंगा।

— रोमन

@ रोमन: जब मैं तुलना में नटखट महसूस करता हूं, तब भी शाओमी के साथ एक और चाल जोड़ने में खुशी होती है। ;-)

— मिचेल मार्ज़क

Answer 5

शायद यह?

if some_condition and condition_a:
       # do something
elif some_condition and condition_b:
           # do something
           # and then exit the outer if block
elif some_condition and not condition_b:
           # more code here
else:
     #blah
if

Comments

हाँ, यह काम कर सकता है। मुझे लगता है कि elifजब मैं यह लिख रहा था, तब मेरे दिमाग में एक तरह की रिक्तता थी। हालांकि मुझे लगता है कि यह उस स्थिति में काम नहीं करेगा जहां मैं बयानों के बीच नेस्टेड के बीच निष्पादन करना चाहता हूं।

— रोमन

यह वास्तव में सही उत्तर है। मैं लोगों को यह सलाह क्यों नहीं देखता हूँ ?? :)

— kerbrose

Answer 6

वास्तव में क्या पूछा गया था, मेरा दृष्टिकोण उन लोगों को ifएक-लूप लूप के अंदर रखना है

while (True):
    if (some_condition):
        ...
        if (condition_a):
            # do something
            # and then exit the outer if block
            break
        ...
        if (condition_b):
            # do something
            # and then exit the outer if block
            break
        # more code here
    # make sure it is looped once
    break

झसे आज़माओ:

conditions = [True,False]
some_condition = True

for condition_a in conditions:
    for condition_b in conditions:
        print("\n")
        print("with condition_a", condition_a)
        print("with condition_b", condition_b)
        while (True):
            if (some_condition):
                print("checkpoint 1")
                if (condition_a):
                    # do something
                    # and then exit the outer if block
                    print("checkpoint 2")
                    break
                print ("checkpoint 3")
                if (condition_b):
                    # do something
                    # and then exit the outer if block
                    print("checkpoint 4")
                    break
                print ("checkpoint 5")
                # more code here
            # make sure it is looped once
            break

Comments

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

— ट्रेंट

के for _ in range(1):बजाय का उपयोग करने पर विचार कर सकते हैं while True:। (1) बेहतर एक एकल पुनरावृत्ति पाश के अपने इरादे संवाद और (2) पाश से बाहर निकलने के लिए कोई अंतिम विराम बयान (बाद में दुर्घटना से हटाया जा सकता है)

— बर्नहार्ड कौसलर

Answer 7

आम तौर पर बोल, नहीं। यदि आप "इफ्स" और उनसे टूट रहे हैं, तो आप इसे गलत कर रहे हैं।

हालाँकि, यदि आपको:

if condition_a:
   def condition_a_fun():
       do_stuff()
       if we_wanna_escape:
           return
   condition_a_fun()
if condition_b:
   def condition_b_fun():
       do_more_stuff()
       if we_wanna_get_out_again:
           return
   condition_b_fun()

ध्यान दें, यदि फ़ंक्शन को इस कथन में घोषित नहीं किया जाता है, तो उन्हें पहले से घोषित किया जा सकता है;) यह एक बेहतर विकल्प होगा, क्योंकि यह बदसूरत बाहर रिफ्लेक्टर करने की आवश्यकता से बच जाएगा यदि / फिर बाद में।

Comments

जवाब के लिए धन्यवाद। मुझे यकीन नहीं है कि 'नेस्टिंग लूप्स' से आपका क्या मतलब है। यदि आप कीवर्ड 'ब्रेक' के मेरे उल्लेख का उल्लेख कर रहे हैं, तो मैं बस एक लूप से बाहर निकलने की तुलना करके मेरी खोज को प्रेरित करने की कोशिश कर रहा था। इसके अलावा, मैं अनिश्चित हूं कि आपका कोड समस्या को कैसे हल करता है, जैसा कि मेरे उदाहरण में था if condition_aऔर if condition_bएक के अंदर घोंसला था if some_condition। मैं इससे बाहर निकलने में सक्षम होना चाहता हूं if some_condition।

— रोमन

लोग इफ्स को तोड़ना चाहते हैं और उन्हें तोड़ना शायद इसलिए नहीं है क्योंकि वे इसे गलत कर रहे हैं, बल्कि शायद इसलिए कि वे साफ सरल और डीआरवाई कोड लिखना चाहते हैं। साधारण मामला तब होता है जब प्रोग्राम को x () करने की आवश्यकता होती है जब दोनों condition_a और condition_b पूरी हो जाती हैं, और केवल कंडीशन_ए के लिए y () करने की आवश्यकता होती है, और केवल condition_b के लिए z () करने की आवश्यकता होती है। और कोडर ने कई बार x () लिखने से मना कर दिया

— izzulmakin

Answer 8

प्रभावी रूप से आप जो वर्णन कर रहे हैं वह गोटो स्टेटमेंट्स हैं, जो आम तौर पर बहुत भारी रूप से प्रतिबंधित हैं। आपका दूसरा उदाहरण समझना आसान है।

हालाँकि, क्लीनर अभी भी होगा:

if some_condition:
   ...
   if condition_a:
       your_function1()
   else:
       your_function2()

...

def your_function2():
   if condition_b:
       # do something
       # and then exit the outer if block
   else:
       # more code here

Answer 9

एक और तरीका है जो फ़ाइनिंग फ़ंक्शंस पर निर्भर नहीं करता है (क्योंकि कभी-कभी छोटे कोड स्निपेट के लिए यह कम पठनीय होता है), एक अतिरिक्त बाहरी का उपयोग नहीं करता है जबकि लूप (जिसे पहली नज़र में भी समझने योग्य होने के लिए टिप्पणियों में विशेष प्रशंसा की आवश्यकता हो सकती है) , गोटो (...) का उपयोग नहीं करते हैं और सबसे महत्वपूर्ण बात यह है कि आप बाहरी के लिए अपना इंडेंटेशन स्तर रखते हैं यदि आपको घोंसले के शिकार सामान शुरू करने की आवश्यकता नहीं है।

if some_condition:
   ...
   if condition_a:
       # do something
       exit_if=True # and then exit the outer if block
if some condition and not exit_if: # if and only if exit_if wasn't set we want to execute the following code
   # keep doing something
   if condition_b:
       # do something
       exit_if=True # and then exit the outer if block
if some condition and not exit_if:
   # keep doing something

हां, इसके लिए पठनीयता के लिए दूसरे रूप की भी आवश्यकता होती है, हालांकि, यदि कोड के स्निपेट छोटे होते हैं, तो इसे किसी भी ट्रैक करने की आवश्यकता नहीं होती है, जो कि लूप्स को कभी नहीं दोहराएगा और यह समझने के बाद कि मध्यवर्ती के लिए क्या है, यह आसानी से पठनीय है, सभी में एक जगह और एक ही इंडेंटेशन के साथ।

और यह बहुत कुशल होना चाहिए।

Answer 10

तो यहाँ मैं समझता हूँ कि यदि आप कोड ब्लॉक करते हैं तो आप बाहरी से बाहर निकलने की कोशिश कर रहे हैं

if some_condition:
    ...
    if condition_a:
       # do something
       # and then exit the outer if block
       ...
    if condition_b:
       # do something
       # and then exit the outer if block
# more code here

इसका एक तरीका यह है कि आप बाहरी ब्लॉक में एक गलत स्थिति के लिए परीक्षण कर सकते हैं, जो तब ब्लॉक ब्लॉक से बाहर निकलेगा, तब आप किसी अन्य ब्लॉक को घोंसले के लिए उपयोग कर सकते हैं अगर कुछ करने के लिए

if test_for_false:
    # Exit the code(which is the outer if code)

else:
    if condition_a:
        # Do something

    if condition_b:
        # Do something

Answer 11

केवल एक चीज जो अतिरिक्त तरीकों के बिना इसे लागू करेगी elifवह निम्न उदाहरण के रूप में है

a = ['yearly', 'monthly', 'quartly', 'semiannual', 'monthly', 'quartly', 'semiannual', 'yearly']
# start the condition
if 'monthly' in b: 
    print('monthly') 
elif 'quartly' in b: 
    print('quartly') 
elif 'semiannual' in b: 
    print('semiannual') 
elif 'yearly' in b: 
    print('yearly') 
else: 
    print('final') 

Answer 12

इसे संभालने का एक और तरीका यहां दिया गया है। यह लूप के लिए एक एकल आइटम का उपयोग करता है जो आपको जारी रखने के लिए सक्षम बनाता है। यह अनावश्यक कारण को बिना किसी कारण के अतिरिक्त कार्य करने से रोकता है। और इसके अलावा छोरों जबकि संभावित अनंत को समाप्त करता है।

if something:
    for _ in [0]:
        # Get x
        if not x:
            continue

        # Get y
        if not y:
            continue

        # Get z
        if not z:
            continue

        # Stuff that depends on x, y, and z

Answer 13

returnयदि इस स्थिति में उपयोग आपको फ़ंक्शन से वापस लौटा देगा, ताकि आप if स्थिति को तोड़ने के लिए रिटर्न का उपयोग कर सकें।

Comments

वह तोड़ने के लिए है, तो समारोह से बाहर निकलने नहीं चाहता है

— StealthOne