पाश

Question

के लिए एक में एक यात्रा वापस ले जा रहा है तो मैं इस तरह कुछ करना चाहता हूँ:

for i in range(5): 
    print(i); 
    if(condition==true): 
     i=i-1; 

हालांकि, जो भी कारण के लिए, भले ही मैं मैं decrementing रहा हूँ, पाश सूचना के लिए प्रतीत नहीं होता। पुनरावृत्ति को दोहराने का कोई तरीका है?

Answer 1

for पायथन में लूप हमेशा आगे बढ़ते हैं। आप पीछे की ओर ले जाने के लिए सक्षम होना चाहते हैं, तो आप, विभिन्न प्रक्रियाओं के उपयोग करना चाहिए इस तरह के while के रूप में:

i = 0 
while i < 5: 
    print(i) 
    if condition: 
     i=i-1 
    i += 1 

या और भी बेहतर:

i = 0 
while i < 5: 
    print(i) 
    if condition: 
     do_something() 
     # don't increment here, so we stay on the same value for i 
    else: 
     # only increment in the case where we're not "moving backwards" 
     i += 1 

Answer 2

आपको पाइथन में लूप के बारे में गलतफहमी है। for लूप प्रत्येक पुनरावृत्ति पर i के साथ आप क्या करते हैं परवाह नहीं करते हैं, क्योंकि यह लूप के तर्क से संबंधित नहीं है। संशोधित i बस स्थानीय चर को पुनर्निर्मित करता है।

जहां i के राज्य लूप के नियंत्रण प्रवाह को प्रभावित करता है आप व्यवहार आप उम्मीद कर रहे हैं प्राप्त करने के लिए थोड़ी देर के पाश का उपयोग करने की आवश्यकता होगी:

import random 

i = 0 
while i < 5: 
    print(i) 
    i += 1 
    if random.choice([True, False]): 
     i -= 1 

Answer 3

अजगर पाश range का उपयोग करके डिजाइन कर रहे हैं सी/सी ++/जावा for -loops से अलग होना। प्रत्येक पुनरावृत्ति के लिए, मैं range(5) का अगला मान निर्धारित करता हूं, इससे कोई फर्क नहीं पड़ता कि आप i के बीच क्या करते हैं।

i = 0 
while i<5: 
    print i 
    if condition: 
     continue 
    i+=1 

लेकिन ईमानदारी से:

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

i = 0 
while i < 5: 
    print(i) 
    if condition: 
     i -= 1 
    i += 1 

के रूप में उल्लेख किया गया है, इस बल्कि unidiomatic अजगर है:

Answer 4

एक while पाश का उपयोग करें। शायद अगर आप जो हासिल करने की कोशिश कर रहे हैं उसे पोस्ट करते हैं तो हम कुछ बेहतर सलाह दे सकते हैं।

Answer 5

range(5) उस में 4 के माध्यम से संख्या 0 साथ एक सूची बनाता है - [0, 1, 2, 3, 4]।

जब आप इसे लूप के लिए चलाते हैं, तो आप सूची में फिर से चल रहे हैं। i-= 1 करने से सूची के उस विशेष तत्व के मूल्य में कमी आएगी, और पुनरावृत्ति जारी रहेगी।

अन्य उत्तरों की तरह यहां सुझाव दिया गया है, आपको while लूप का उपयोग करना चाहिए।

i= 0 
while i<5: 
    # do stuff 
    if #condition: 
     i-= 1 # or + 
    i+= 1 

Answer 6

कई अन्य जवाब दोहरा, और सिर्फ पूर्णता के लिए, आप एक while loop उपयोग करने के लिए की आवश्यकता होगी।

i = 0 
while i < 5: 
    print(i) 
    if (not condition): 
     i+=1 

आप पाश में एक यात्रा वापस ले जाने के (बजाय एक यात्रा दोहराने की) चाहते हैं, तो इस का उपयोग करें:

i = 0 
while i < 5: 
    print(i) 
    if (condition): 
     i -= 1 
    else: 
     i += 1 

अनिवार्य रूप से, while i < 5 प्रत्येक यात्रा पर मूल्यांकन करती है और इसकी जांच करता है i < 5। (i के मूल्यों)

बदलते नहीं: 1->2->3-(condition satisfied)> 3 -> 4 -> 5

decrementing: 1->2->3-(condition satisfied)>2 -> 3 -> 4 -> 5

कारण है कि i=i-1 में पाश के लिए अपनी नहीं है इस प्रकार decrementing/i नहीं बदल रहा है, हम कुछ इस तरह मिल यह पुनरावृत्ति दोहराना सरल है। for लूप में, i को लूप के लिए अगले आइटम का मान असाइन किया गया है। पाइथन i के साथ आप जो भी करते हैं उसके बारे में कम ख्याल रख सकते हैं, जब तक कि यह अगले आइटम को असाइन करने में सक्षम हो। इस प्रकार, पाश for i in <your_iterable>:<do whatever> के लिए इस के करीब है:

_i = 0 
_length = len(<your_iterable>) 
while _i < _length: 
    i = _i 
    _i += 1 
    <do whatever> 

हालांकि, इस सादृश्य में, तुम नहीं _ predicated चर (_i, _length) उपयोग करने में सक्षम हो जाएगा। इस प्रकार मैं for loop के तर्क को सरल बना देता हूं। ध्यान दें कि i को असाइन किए जाने के बावजूद, इसे अगले पुनरावृत्ति पर _i पर असाइन किया जाएगा, और लूप वास्तव में i के बारे में परवाह नहीं करता है।

Answer 7

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

def repeateble(it): 
    buf, it = None, iter(it) 
    while True: 
     if buf is None: 
      # the buffer is empty, send them the next elem 
      val = next(it) 
     else: 
      # there's something in the buffer 
      # let's send that back 
      val = buf 

     # send the value and wait what they say 
     back = yield val 

     if back: 
      # they've sent us something! 
      # give them some dummy value as a result of send() 
      yield None 
      # and save what they've sent in a buffer 
      # for the next iteration 
      buf = back 

     else: 
      # they haven't sent anything 
      # empty the buffer 
      buf = None 


from random import randint 

# create a repeateble generator 
rng = repeateble(range(100)) 

for x in rng: 
    print(x) 

    # check "some condition"... 
    if randint(1, 100) > 80: 
     print('repeat:') 
     # send the current value back to the generator 
     # it will be returned on the next iteration 
     rng.send(x)