अजगर लूप के लिए 'और' का उपयोग क्यों करता है?

480

मैं समझता हूं कि यह निर्माण कैसे काम करता है:

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

    if i == 9:
        print("Too big - I'm giving up!")
        break;
else:
    print("Completed successfully")

लेकिन मुझे समझ में नहीं आता है कि elseयहाँ खोजशब्द के रूप में क्यों प्रयोग किया जाता है, क्योंकि यह सुझाव देता है कि प्रश्न में कोड केवल तभी चलता है जब forब्लॉक पूरा नहीं होता है, जो इसके विपरीत होता है! कोई फर्क नहीं पड़ता कि मैं इसके बारे में कैसे सोचता हूं, मेरा मस्तिष्क forबयान से elseब्लॉक तक मूल रूप से प्रगति नहीं कर सकता है । मेरे लिए, continueया continuewithअधिक समझ में आता है (और मैं इस तरह से पढ़ने के लिए खुद को प्रशिक्षित करने की कोशिश कर रहा हूं)।

मैं सोच रहा हूँ कि पायथन कोडर्स ने इस निर्माण को अपने सिर में कैसे पढ़ा (या यदि आप चाहें तो)। शायद मुझे कुछ याद आ रहा है जो ऐसे कोड ब्लॉक को आसानी से समझने योग्य बना देगा?

python  if-statement  for-loop  for-else 
— केंट बूगार्ट
स्रोत
26
आप इसे अपने सिर में "तब" अनुवाद करना पसंद कर सकते हैं।
— मार्सिन
63
पायथन के ज़ेन में मुख्य पंक्ति को मत भूलना: "... जब तक आप डच नहीं होंगे तब तक यह तरीका स्पष्ट नहीं हो सकता है।"
— डैनियल रोजमैन
50
मेरे सिर में मैं इसे "अगर नहीं तोड़ता" में अनुवाद करता हूं । और, चूंकि मुझे "यह मिल गया है" लूप्स breakमें बहुत उपयोग किया जाता है , आप इसे "यदि नहीं मिला है" में अनुवाद कर सकते हैं , जो कि क्या पढ़ता है, उससे बहुत दूर नहीं हैelse
— मेस्ट्रेलेन
29
मुझे लगता है कि असली सवाल कई लोगों के यहाँ है "क्या अंतर है for ... else foo()और सिर्फ foo()लूप के लिए डाल रहा है ?" और जवाब यह है कि वे केवल तभी अलग व्यवहार करते हैं जब लूप शामिल हो break(जैसा कि नीचे विस्तार से वर्णित है)।
— सैम कॉफ़मैन
10
अजगर में एक अर्धविराम ... मेरी आँखें
— दुखती हैं

जवाबों:

277

यह एक अजीब निर्माण भी अनुभवी अजगर कोडर के लिए है। जब फॉर-लूप्स के साथ संयोजन के रूप में उपयोग किया जाता है तो इसका मूल रूप से मतलब है "कुछ आइटम को पुनरावृत्ति में ढूंढें, और यदि कोई नहीं मिला ..."। जैसे की:

found_obj = None
for obj in objects:
    if obj.key == search_key:
        found_obj = obj
        break
else:
    print('No object found.')

लेकिन जब भी आप इस निर्माण को देखते हैं, एक बेहतर विकल्प या तो किसी फ़ंक्शन में खोज को एनकैप्सुलेट करना है:

def find_obj(search_key):
    for obj in objects:
        if obj.key == search_key:
            return obj

या सूची समझ का उपयोग करें:

matching_objs = [o for o in objects if o.key == search_key]
if matching_objs:
    print('Found {}'.format(matching_objs[0]))
else:
    print('No object found.')

यह शब्दार्थ दो अन्य संस्करणों के समतुल्य नहीं है, लेकिन गैर-प्रदर्शन महत्वपूर्ण कोड में काफी अच्छा काम करता है, जहां यह कोई फर्क नहीं पड़ता कि आप पूरी सूची को पुनरावृत्त करते हैं या नहीं। अन्य लोग असहमत हो सकते हैं, लेकिन मैं व्यक्तिगत रूप से उत्पादन कोड में फ़ोर-फ़ोर या जबकि-ब्लॉक का उपयोग करने से कभी भी बचूंगा।

यह भी देखें [अजगर-विचार] का सारांश ... और सूत्र

— ब्योर्न लिंडक्विस्ट
स्रोत
50
सूची की समझ गलत एक-लाइनर है। आप के रूप में, एक ही आइटम के लिए देख रहे हैं forपाश उदाहरण है, और एक जनरेटर अभिव्यक्ति / सूची समझ का उपयोग करना चाहते हैं, तो आप चाहते हैं next((o for o in objects if o.key == search_key), None)या एक में लपेट try/ exceptऔर एक के बजाय कोई डिफ़ॉल्ट मान का उपयोग if/ else।
— agf
4
और लांस हेलस्टन के उत्तर की तरह, वास्तविक मामले हैं जहां for/elseनिर्माण का उपयोग करना बेहतर है ।
— andrean
5
चीयर्स। मेरे पास एक बुरी तरह से इंडेंट की गई फ़ाइल थी, जहाँ एक elseजोड़ी बन गई forथी और मुझे नहीं पता था कि यह कानूनी था।
— अधिकतम
3
मुझे लगता है कि लूप के लिए वहां के निर्माण सबसे स्पष्ट हैं।
— माइल्स राउत
14
यह उल्लेखनीय है कि लूप के लिए मान तब भी चलता है, जब तक कि कोई breakकथन इस उदाहरण की तरह खोजपूर्णता न हो। ऊपर दिए गए डॉक्स से: " elseक्लॉज की एक और कथित समस्या है: यदि breakलूप में नहीं है, तो elseक्लॉज कार्यात्मक बेमानी है।" जैसेfor x in [1, 2, 3]:\n print x\n else:\n print 'this executes due to no break'
— dhackner
586

एक सामान्य निर्माण एक लूप चलाना है जब तक कि कुछ नहीं मिलता है और फिर लूप से बाहर निकलने के लिए। समस्या यह है कि यदि मैं लूप से बाहर निकलता हूं या लूप समाप्त हो जाता है, तो मुझे यह निर्धारित करने की आवश्यकता है कि कौन सा मामला हुआ। एक विधि एक ध्वज या स्टोर चर बनाने की है जो मुझे यह देखने के लिए दूसरा परीक्षण करने देगा कि पाश कैसे बाहर निकल गया था।

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

अजगर का उपयोग करना for... elseनिर्माण आपके पास है

for i in mylist:
    if i == theflag:
        break
    process(i)
else:
    raise ValueError("List argument missing terminal flag.")

इसकी तुलना एक ऐसी विधि से करें, जो इस संश्लिष्ट चीनी का उपयोग नहीं करती है:

flagfound = False
for i in mylist:
    if i == theflag:
        flagfound = True
        break
    process(i)

if not flagfound:
    raise ValueError("List argument missing terminal flag.")

पहले मामले में raiseयह जिस लूप के साथ काम करता है उसके लिए कसकर बाध्य है। दूसरे में बाध्यकारी उतना मजबूत नहीं है और रखरखाव के दौरान त्रुटियों को पेश किया जा सकता है।

— लांस हेलस्टन
स्रोत
69
यह इसे चुने गए उत्तर से बेहतर समझाता है जहाँ लेखक को वास्तव में वह नहीं मिलता है, जिसके बारे में और क्या है!
— एरिकाबवर्क
17
मेरा कहना है कि यह सिन्गनेटिक शुगर आपके प्रोजेक्ट के दांतों को सड़ सकता है। यह एक Python: the good partsकिताब नहीं होगी ।
— बोटकोडर
1
क्या आप इस बात की पुष्टि कर सकते हैं कि आपके उदाहरण में, process(i)प्रत्येक आइटम के लिए mylistसख्ती से पहले theflagऔर theflagखुद के लिए नहीं होता है? क्या यह इरादा था?
— ब्लि
4
processपहुंच जाने iसे पहले सूची में मौजूद प्रत्येक पर अमल करेंगे theflag, इसे बाद में सूची में तत्वों पर निष्पादित नहीं किया जाएगा theflag, और इसे निष्पादित नहीं किया जाएगा theflag।
— लांस हेलस्टर्न
1
अन्य कथन को भी निष्पादित किया जाता है अगर उसमें चलने योग्य कोई तत्व नहीं है
— खो दिया Crotchet
173

रेमंड हेटिंगर द्वारा एक उत्कृष्ट प्रस्तुति है, जिसका शीर्षक है ट्रांसफॉर्मिंग कोड इन ब्यूटीफुल, इडियोमैटिक पायथन , जिसमें वह संक्षिप्त रूप से for ... elseनिर्माण के इतिहास को संबोधित करते हैं । संबंधित अनुभाग "छोरों में कई निकास बिंदुओं को भेद करना" 15:50 से शुरू होता है और लगभग तीन मिनट तक जारी रहता है। यहाँ उच्च बिंदु हैं:

  • for ... elseनिर्माण कुछ के लिए एक स्थानापन्न के रूप में डोनाल्ड नुथ द्वारा तैयार किया गया था GOTOउपयोग के मामलों;
  • elseकीवर्ड का फिर से उपयोग करना समझ में आता है क्योंकि "यह वही है जिसे नथ ने इस्तेमाल किया था, और लोग जानते थे, उस समय, सभी [ forबयान] एक ifऔर GOTOनीचे की ओर एम्बेडेड थे , और उन्हें उम्मीद थी कि else;"
  • अड़चन में, इसे "नो ब्रेक" (या संभवतः "नॉब्रीक") कहा जाना चाहिए था, और फिर यह भ्रामक होगा। *

तो, अगर सवाल है, "वे इस कीवर्ड को क्यों नहीं बदलते हैं?" तब कैट प्लस प्लस ने संभवतः सबसे सटीक जवाब दिया था - इस बिंदु पर, यह व्यावहारिक होने के लिए मौजूदा कोड के लिए बहुत विनाशकारी होगा। लेकिन अगर आप वास्तव में पूछ रहे हैं elseकि पहले स्थान पर पुन: उपयोग क्यों किया गया था, ठीक है, जाहिर है यह उस समय एक अच्छा विचार था।

व्यक्तिगत रूप से, मुझे # no breakइन-लाइन में टिप्पणी करने का समझौता पसंद है, जहां elseगलत हो सकता है, एक नज़र में, जैसा कि लूप के अंदर होता है। यह काफी स्पष्ट और संक्षिप्त है। इस विकल्प को सारांश में एक संक्षिप्त उल्लेख मिलता है जिसे ब्योर्न ने अपने उत्तर के अंत में जोड़ा था:

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

for item in sequence:
    process(item)
else:  # no break
    suite

* वीडियो के उस हिस्से से बोनस उद्धरण: "जैसे अगर हम लंबोदर को बुलावा देते हैं, तो कोई भी नहीं पूछेगा, ' मेमना क्या करता है?'

— वायु
स्रोत
33

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

— बिल्ली प्लस प्लस
स्रोत
2
लगता finallyहै कि मामले में एक बेहतर विकल्प होता। जिस समय यह निर्माण पेश किया गया था उस समय अंत में कीवर्ड मौजूद नहीं था?
— पोंकाडूडल
26
@Wallacoloo finallyज्यादा बेहतर नहीं है, क्योंकि इसका तात्पर्य है कि लूप के बाद ब्लॉक को हमेशा निष्पादित किया जाएगा, और यह नहीं है (क्योंकि यह लूप के बाद चलने के लिए कोड डालने के साथ बेमानी होगा)।
— कैट प्लस
यह इसलिए भी नहीं हो सकता है finallyक्योंकि continueलूप के लिए उपयोग किए जाने पर अन्य क्लॉज़ को भी निष्पादित किया जाता है - जो कि संभवतः कई बार होता है और न केवल अंत में होता है।
— पीपर
6
@pepr elseक्लॉज निष्पादन continue( डॉक्स और टेस्ट कोड ) से प्रभावित नहीं होता है
— एयर
@ एरीथोमास: +1। तुम सही हो। elseनिष्पादित किया जाता है केवल जब continueपिछले यात्रा के लिए एक था।
— पेजर
33

इसे सरल बनाने के लिए, आप इसे इस तरह से सोच सकते हैं;

  • यदि यह लूप breakमें कमांड का सामना करता है for, तो elseहिस्सा नहीं कहा जाएगा।
  • यदि यह लूप breakमें कमांड का सामना नहीं करता है for, तो elseभाग को बुलाया जाएगा।

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

— एड इन्फिटम
स्रोत
elseब्लॉक भी अगर पाश के शरीर एक अपवाद को जन्म देती है नहीं निष्पादित किया जाएगा।
— अमल के
17

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

for a in range(3):
    print(a)
    if a==4: # change value to force break or not
        break
else: #no break  +10 for whoever thought of this decoration
    print('for completed OK')

print('statement after for loop')
— Neil_UK
स्रोत
"ब्रेक ब्लॉक से बाहर कूदता है, और इसलिए 'अन्य क्लॉज' पर 'कूदता है" - जबकि यह "पाने" for:/ के एक तरीके के रूप में सहायक हो सकता है else:, यह वास्तव में कीवर्ड के लिए एक औचित्य प्रदान नहीं करता है else। यहां दिए गए फ्रेमिंग को देखते हुए, then:ऐसा लगता है कि यह बहुत अधिक स्वाभाविक होगा। ( चुने जाने के कारण हैंelse , अन्य जवाबों में दिए गए हैं - वे सिर्फ यहां प्रदान नहीं किए गए हैं।)
— मार्क एमी
16

मुझे लगता है कि दस्तावेज़ीकरण की एक और व्याख्या है , जारी रखें

[...] इसे तब निष्पादित किया जाता है जब सूची की थकावट के माध्यम से लूप समाप्त हो जाता है (तब के लिए) या जब स्थिति झूठी हो जाती है (थोड़ी देर के साथ), लेकिन तब नहीं जब लूप को ब्रेक स्टेटमेंट द्वारा समाप्त किया जाता है। "

स्रोत: पायथन 2 डॉक्स: नियंत्रण प्रवाह पर ट्यूटोरियल

— अयान
स्रोत
13

मैंने इसे कुछ इस तरह पढ़ा:

शर्तों पर अभी भी लूप को चलाने के लिए करते हैं, तो सामान, कर कुछ और कुछ और।

— pcalcao
स्रोत
शर्तों पर आपका अभी भी सहायक है (+1) हालांकि यह गलत है - यह मानव है ;-)
— वुल्फ
-1; यह उच्चारण for:/ else:ऐसा लगता है जैसे else:कि लूप के बाद हमेशा चलेगा, जो ऐसा नहीं है।
— मार्क अमेरी
11

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

पायथन एक बहुत ही आकर्षक प्रोग्रामिंग भाषा होने के नाते , एक कीवर्ड का दुरुपयोग अधिक कुख्यात है। elseकीवर्ड पूरी तरह से एक निर्णय पेड़ के प्रवाह के हिस्से का वर्णन, "यदि आप ऐसा नहीं कर सकते हैं, (बाकी) ऐसा"। यह हमारी अपनी भाषा में निहित है।

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

if / else अनुसरण करने के लिए एक मार्ग इंगित करें । "लक्ष्य" पूरा होने तक लूप्स एक पथ का अनुसरण करते हैं ।

मुद्दा यह है कि elseयह एक ऐसा शब्द है जो किसी स्थिति में अंतिम विकल्प को स्पष्ट रूप से परिभाषित करता है। अर्थ विज्ञान शब्द के दोनों कर रहे हैं साझा अजगर और मानव भाषा से। लेकिन मानव भाषा में दूसरे शब्द का उपयोग कभी किसी को कुछ करने के लिए या कुछ पूरा होने के बाद करने के लिए इंगित नहीं किया जाता है। इसका उपयोग किया जाएगा, अगर इसे पूरा करने की प्रक्रिया में, एक मुद्दा उठता है (एक ब्रेक स्टेटमेंट की तरह )।

अंत में, कीवर्ड पायथन में रहेगा। यह स्पष्ट है कि यह गलती थी, स्पष्ट है जब प्रत्येक प्रोग्रामर किसी न किसी प्रकार के मेनेमोनिक डिवाइस के उपयोग को समझने के लिए कहानी के साथ आने की कोशिश करता है। मुझे अच्छा लगा अगर वे खोजशब्द के बजाय चुना है then। मेरा मानना ​​है कि यह कीवर्ड उस पुनरावृत्ति प्रवाह में पूरी तरह से फिट बैठता है, लूप के बाद भुगतान ।

यह उस स्थिति से मिलता-जुलता है, जो किसी बच्चे के पास खिलौने को इकट्ठा करने के हर चरण का पालन करने के बाद होती है: और तब क्या पिताजी?

— 3rdWorldCitizen
स्रोत
मुझे लगता है कि यह जवाब भ्रम के मुद्दे को संबोधित करता है मुझे लगता है कि ओपी के बारे में बात कर रहा था। जब आप के लिए कार्रवाई से जुड़ा हुआ है, तो दूसरा कीवर्ड इसके विपरीत है जो आप अंग्रेजी के अर्थ से उम्मीद करेंगे। सिद्धांत रूप में, के लिए ... और अलग तरीके से काम किया जा सकता है कि आप किसी अन्य भाग में समाप्त हो जाते हैं जब लूप टूट जाता है, लेकिन समस्या यह है कि इसका उपयोग तत्व x खोजने के लिए करें, और मामले को संभालें जहां x नहीं मिला, तो आपको पूरे के बाद एक ध्वज या किसी अन्य परीक्षण का उपयोग करना पड़ सकता है .. अन्यथा निर्माण
— Spacen Jasset
7

मैंने इसे पढ़ा जैसे "जब iterableपूरी तरह से समाप्त हो जाता है, और निष्पादन समाप्त होने के बाद अगले बयान के लिए आगे बढ़ना है for, तो दूसरे खंड को निष्पादित किया जाएगा।" इस प्रकार, जब पुनरावृत्ति इससे टूट जाती है break, तो इसे निष्पादित नहीं किया जाएगा।

— 0xc0de
स्रोत
6

मैं सहमत हूं, यह एक 'एलिफ नॉट [कंडीशन (एस) राइजिंग ब्रेक]' की तरह है।

मुझे पता है कि यह एक पुराना धागा है, लेकिन मैं अभी उसी प्रश्न पर गौर कर रहा हूं, और मुझे यकीन नहीं है कि किसी ने भी इस प्रश्न के उत्तर को जिस तरह से समझा है, उस पर कब्जा कर लिया है।

मेरे लिए, या बयानों elseमें "पढ़ने" के तीन तरीके हैं , जिनमें से सभी समान हैं:For... elseWhile... else

  1. else == if the loop completes normally (without a break or error)
  2. else == if the loop does not encounter a break
  3. else == else not (condition raising break) (संभवतः ऐसी कोई स्थिति है, या आपके पास लूप नहीं होगा)

तो, अनिवार्य रूप से, एक लूप में "और" वास्तव में एक "एलिफ ..." है, जहां '...' (1) कोई ब्रेक नहीं है, जो (2) नहीं के बराबर है (स्थिति) ब्रेक को बढ़ाता है]।

मुझे लगता है कि कुंजी else'ब्रेक' के बिना बेकार है, इसलिए for...elseइसमें शामिल हैं:

for:
    do stuff
    conditional break # implied by else
else not break:
    do more stuff

तो, एक for...elseलूप के आवश्यक तत्व निम्नानुसार हैं, और आप उन्हें सादे अंग्रेजी में पढ़ेंगे:

for:
    do stuff
    condition:
        break
else: # read as "else not break" or "else not condition"
    do more stuff

जैसा कि अन्य पोस्टरों ने कहा है, आम तौर पर एक ब्रेक उठाया जाता है जब आप यह पता लगाने में सक्षम होते हैं कि आपका लूप क्या ढूंढ रहा है, इसलिए else:"लक्ष्य आइटम स्थित नहीं है तो क्या करना है" बन जाता है।

उदाहरण

आप अपवाद हैंडलिंग, ब्रेक और सभी छोरों के लिए भी एक साथ उपयोग कर सकते हैं।

for x in range(0,3):
    print("x: {}".format(x))
    if x == 2:
        try:
            raise AssertionError("ASSERTION ERROR: x is {}".format(x))
        except:
            print(AssertionError("ASSERTION ERROR: x is {}".format(x)))
            break
else:
    print("X loop complete without error")

परिणाम

x: 0
x: 1
x: 2
ASSERTION ERROR: x is 2
----------
# loop not completed (hit break), so else didn't run

उदाहरण

ब्रेक के हिट होने के साथ सरल उदाहरण।

for y in range(0,3):
    print("y: {}".format(y))
    if y == 2: # will be executed
        print("BREAK: y is {}\n----------".format(y))
        break
else: # not executed because break is hit
    print("y_loop completed without break----------\n")

परिणाम

y: 0
y: 1
y: 2
BREAK: y is 2
----------
# loop not completed (hit break), so else didn't run

उदाहरण

सरल उदाहरण जहां कोई विराम नहीं है, विराम को बढ़ाने वाली कोई स्थिति नहीं है, और कोई त्रुटि सामने नहीं आई है।

for z in range(0,3):
     print("z: {}".format(z))
     if z == 4: # will not be executed
         print("BREAK: z is {}\n".format(y))
         break
     if z == 4: # will not be executed
         raise AssertionError("ASSERTION ERROR: x is {}".format(x))
else:
     print("z_loop complete without break or error\n----------\n")

परिणाम

z: 0
z: 1
z: 2
z_loop complete without break or error
----------
— NotAnAmbiTurner
स्रोत
6

यहां elseकीवर्ड भ्रामक हो सकता है, और जैसा कि कई लोगों ने बताया है, जैसे कुछ nobreak, notbreakअधिक उपयुक्त है।

for ... else ...तार्किक रूप से समझने के लिए , इसकी तुलना करें try...except...else, नहीं if...else..., अधिकांश अजगर प्रोग्रामर निम्नलिखित कोड से परिचित हैं:

try:
    do_something()
except:
    print("Error happened.") # The try block threw an exception
else:
    print("Everything is find.") # The try block does things just find.

इसी तरह, breakएक विशेष प्रकार के बारे में सोचें Exception:

for x in iterable:
    do_something(x)
except break:
    pass # Implied by Python's loop semantics
else:
    print('no break encountered')  # No break statement was encountered

अंतर pythonतात्पर्य है except breakऔर आप इसे बाहर नहीं लिख सकते हैं, इसलिए यह बन जाता है:

for x in iterable:
    do_something(x)
else:
    print('no break encountered')  # No break statement was encountered

हां, मुझे पता है कि यह तुलना कठिन और थकाऊ हो सकती है, लेकिन यह भ्रम को स्पष्ट करती है।

— cizixs
स्रोत
जब आप इससे कॉपी करते हैं, तो आपको संसाधन के लिए एक लिंक बनाना चाहिए: निक कॉगलन के पायथन नोट्स ।
— गोडेयागो
@godaygo लिंक के लिए धन्यवाद। जब मैंने पहली बार अजगर को पढ़ा तो मैंने अवधारणा को पढ़ा और स्वीकार किया, उत्तर लिखते समय स्रोत को याद नहीं किया।
— cizixs
@cizixs आपने "स्रोत को याद नहीं किया" लेकिन मूल के समान टिप्पणियों के संपूर्ण वाक्यों को शामिल करने के लिए क्या हुआ? Ooookaaaay।
— मार्क अमेरी
5

लूप नहीं तोड़े जाने पर elseस्टेटमेंट ब्लॉक में कोड निष्पादित किए forजाएंगे।

for x in xrange(1,5):
    if x == 5:
        print 'find 5'
        break
else:
    print 'can not find 5!'
#can not find 5!

से डॉक्स: तोड़ने के लिए और बयान, और पर लूप्स बाकी क्लाज जारी रखने के लिए

लूप स्टेटमेंट में एक और क्लॉज हो सकता है; इसे तब निष्पादित किया जाता है जब सूची की थकावट के माध्यम से लूप समाप्त हो जाता है (के लिए) या जब स्थिति झूठी (थोड़ी देर के साथ) हो जाती है, लेकिन तब नहीं जब लूप को ब्रेक स्टेटमेंट द्वारा समाप्त किया जाता है। यह निम्नलिखित लूप द्वारा अनुकरणीय है, जो प्रमुख संख्याओं की खोज करता है:

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         # loop fell through without finding a factor
...         print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

(हां, यह सही कोड है। बारीकी से देखें: अन्य खंड लूप के लिए है, यदि विवरण नहीं है।)

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

सी से उधार लिया गया जारी बयान, लूप के अगले पुनरावृत्ति के साथ जारी है:

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found a number", num)
Found an even number 2
Found a number 3
Found an even number 4
Found a number 5
Found an even number 6
Found a number 7
Found an even number 8
Found a number 9
— चल पड़ा हूँ अपने रास्ते पर
स्रोत
1
यह कुछ भी नहीं जोड़ता है और इस सवाल का जवाब नहीं देता है, जो कि कैसे लेकिन क्यों नहीं है ।
— एयर
5

यहाँ इसके बारे में सोचने का एक तरीका है कि मैंने किसी और को ऊपर उल्लेख नहीं किया है:

सबसे पहले, याद रखें कि फॉर-लूप मूल रूप से सिंटैक्टिक शुगर हैं जबकि आसपास-लूप। उदाहरण के लिए, लूप

for item in sequence:
    do_something(item)

के रूप में (लगभग) फिर से लिखा जा सकता है

item = None
while sequence.hasnext():
    item = sequence.next()
    do_something(item)

दूसरा, याद रखें कि जबकि-लूप मूल रूप से दोहराए जाते हैं यदि ब्लॉक! आप हमेशा एक लूप पढ़ सकते हैं जैसे "यदि यह स्थिति सही है, तो शरीर को निष्पादित करें, फिर वापस आएं और फिर से जांचें"।

इसलिए, जबकि / और सही समझ में आता है: यह ठीक उसी तरह की संरचना है जैसे कि / अन्यथा, लूपिंग की अतिरिक्त कार्यक्षमता के साथ जब तक कि हालत केवल एक बार स्थिति की जांच करने के बजाय झूठी हो जाती है।

और फिर / अन्यथा के लिए भी सही समझ में आता है: क्योंकि सभी-लूप बस-लूप्स के शीर्ष पर सिंटैक्टिक चीनी हैं, आपको बस यह पता लगाने की आवश्यकता है कि अंतर्निहित लूप के अंतर्निहित सशर्त क्या है, और फिर दूसरे से मेल खाती है हालत झूठी हो जाती है।

— हारून गेबल
स्रोत
4

महान जवाब हैं:

  • यह जो इतिहास की व्याख्या करता है, और
  • यह आपके अनुवाद / समझ को आसान बनाने के लिए सही उद्धरण देता है।

मेरा ध्यान यहां से आता है कि डोनाल्ड नथ ने एक बार कहा था (क्षमा करें संदर्भ नहीं मिल सकता है) कि एक निर्माण है, जहां-जबकि-अगर और (अर्थात् पायथन में) से अप्रभेद्य है:

x = 2
while x > 3:
    print("foo")
    break
else:
    print("boo")

निम्न के समान प्रवाह (निम्न स्तर के अंतर को छोड़कर) है:

x = 2
if x > 3:
    print("foo")
else:
    print("boo")

मुद्दा यह है कि अगर-और को सिंटैक्टिक शुगर के रूप में माना जा सकता है, जबकि breakइसके ifब्लॉक के अंत में निहित है । विपरीत निहितार्थ, वह whileलूप विस्तार है if, अधिक सामान्य है (यह सिर्फ दोहराया / लूप सशर्त जांच है), क्योंकि ifअक्सर पहले सिखाया जाता है while। हालांकि यह सच नहीं है क्योंकि इसका मतलब यह होगा कि जब स्थिति झूठी elseहोगी तो हर बार ब्लॉक किया जाएगा ।

अपनी समझ को आसान बनाने के लिए इस तरह से सोचें:

आदि के बिना break, returnलूप केवल तभी समाप्त होता है जब स्थिति सच नहीं होती है और ऐसे में elseब्लॉक एक बार भी निष्पादित होगा। अजगर के मामले में forआपको सी-स्टाइल forलूप (शर्तों के साथ) पर विचार करना चाहिए या उनका अनुवाद करना होगा while।

एक और नोट:

समय से पहले break, returnइत्यादि के अंदर पाश क्योंकि निष्पादन लूप से बाहर कूद गया, जबकि हालत सच था और यह कभी वापस मत आना इसे फिर से जांच करने के लिए होगा हालत झूठी बनने के लिए असंभव बना देता है।

— WloHu
स्रोत
3

आप ऐसा सोच सकते हैं, elseजैसे कि बाकी सामान, या अन्य सामान, जो लूप में नहीं किया गया था।

— jamylak
स्रोत
3 
for i in range(3):
    print(i)

    if i == 2:
        print("Too big - I'm giving up!")
        break;
else:
    print("Completed successfully")

"और" यहाँ पागलपन सरल है, बस मतलब है

1, "अगर for clauseपूरा हो गया है"

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

    if i == 2:
        print("Too big - I'm giving up!")
        break;
if "for clause is completed":
    print("Completed successfully")

यह इस तरह के लंबे वक्तव्यों को "खंड पूरा होने" के लिए लिखने के लिए तैयार कर रहा है, इसलिए वे "और" पेश करते हैं।

else यहाँ एक है अगर इसकी प्रकृति में।

2, हालांकि, कैसे के बारे में for clause is not run at all

In [331]: for i in range(0):
     ...:     print(i)
     ...: 
     ...:     if i == 9:
     ...:         print("Too big - I'm giving up!")
     ...:         break
     ...: else:
     ...:     print("Completed successfully")
     ...:     
Completed successfully

तो यह पूरी तरह से कथन तर्क संयोजन है:

if "for clause is completed" or "not run at all":
     do else stuff

या इसे इस तरह से रखें:

if "for clause is not partially run":
    do else stuff

या इस तरह:

if "for clause not encounter a break":
    do else stuff
— गणना
स्रोत
SQL में "लेनदेन" के रूप में कार्य करता है।
— कलन
2

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

import socket
import time

sock = socket.socket()
timeout = time.time() + 15
while time.time() < timeout:
    if sock.connect_ex(('127.0.0.1', 80)) is 0:
        print('Port is open now!')
        break
    print('Still waiting...')
else:
    raise TimeoutError()
— जोनाथन सुदियमन
स्रोत
1

मैं बस फिर से खुद को समझने की कोशिश कर रहा था। मैंने पाया कि निम्नलिखित मदद करता है!

• लूप elseके ifअंदर के साथ जोड़े जाने के बारे में सोचें (बजाय इसके साथ for) - अगर शर्त पूरी होती है तो लूप को तोड़ दें, बाकी ऐसा करें - सिवाय एक elseके कई जोड़े के साथ if!
• यदि कोई ifभी व्यक्ति पूरी तरह से संतुष्ट नहीं हैं , तो ऐसा करें else।
• कई ifएस वास्तव में के रूप में सोचा जा सकता है if- elifएस!

— जर्मेन गोह
स्रोत
-2

मैं संरचना को इस प्रकार मानता हूं (यदि) A और B, और (यदि) -Lse एक विशेष अगर-और , मोटे तौर पर है । इससे और समझने में मदद मिल सकती है ।

ए और बी को एक बार में निष्पादित किया जाता है, जो कि अगर-और संरचना के समान है।

के लिए (यदि) एक विशेष माना जा सकता है अगर, जो एक लूप करता है यदि वह इस स्थिति को पूरा करने की कोशिश करता है। एक बार अगर शर्त पूरी हो जाती है, तो ए और ब्रेक ; एल्स , बी।

— जी झांग
स्रोत
-2

पायथन बाद में और छोरों के लिए एक और का उपयोग करता है ताकि यदि लूप पर कुछ भी लागू न हो, तो कुछ और हो। उदाहरण के लिए:

test = 3
while test == 4:
     print("Hello")
else:
     print("Hi")

आउटपुट 'हाय' बार-बार होगा (यदि मैं सही हूं)।

— Mrmongoose64
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.