अजगर सूची इटरेटर व्यवहार और अगले (इटरेटर)

Question

पर विचार करें:

>>> lst = iter([1,2,3]) 
>>> next(lst) 
1 
>>> next(lst) 
2 

तो, इटरेटर आगे बढ़ रहा है, के रूप में उम्मीद, परिवर्तनशील एक ही वस्तु है कि द्वारा नियंत्रित किया।

यह किया जा रहा मामला है, मैं उम्मीद करेंगे:

a = iter(list(range(10))) 
for i in a: 
    print(i) 
    next(a) 

हर दूसरे तत्व को छोड़ने के लिए: next करने के लिए कॉल एक बार इटरेटर अग्रिम चाहिए, फिर निहित पाश द्वारा किए गए कॉल यह दूसरी बार अग्रिम चाहिए - और इस दूसरे कॉल का नतीजा i को सौंपा जाएगा।

ऐसा नहीं है। लूप सूची में आइटमों के सभी प्रिंट करता है, बिना किसी छोड़े किए।

मेरा पहला विचार यह था कि ऐसा हो सकता है क्योंकि लूप iter को पारित होने पर कॉल करता है, और यह एक स्वतंत्र इटरेटर दे सकता है - ऐसा नहीं है, क्योंकि हमारे पास iter(a) is a है।

तो, next क्यों इस मामले में पुनरावर्तक को अग्रिम नहीं करता है?

Answer 1

में ठीक से काम करता क्या आप देख दुभाषियाi के अलावा next() के रिटर्न मान वापस गूंज मुद्रित किया जा रहा प्रत्येक यात्रा है:

>>> a = iter(list(range(10))) 
>>> for i in a: 
... print(i) 
... next(a) 
... 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 

तो 0print(i) का उत्पादन होता है, 1 वापसी इंटरैक्टिव दुभाषिया इत्यादि द्वारा प्रतिबिंबित next() से मूल्य, केवल 5 पुनरावृत्तियों हैं, प्रत्येक पुनरावृत्ति जिसके परिणामस्वरूप टर्मिनल में 2 लाइनें लिखी जा रही हैं।

आप next() चीजों के उत्पादन अपेक्षित तरीके से असाइन करते हैं:

>>> a = iter(list(range(10))) 
>>> for i in a: 
... print(i) 
... _ = next(a) 
... 
0 
2 
4 
6 
8 

या प्रिंट अतिरिक्त जानकारी इंटरैक्टिव दुभाषिया गूंज से print() उत्पादन अंतर करने के लिए:

>>> a = iter(list(range(10))) 
>>> for i in a: 
... print('Printing: {}'.format(i)) 
... next(a) 
... 
Printing: 0 
1 
Printing: 2 
3 
Printing: 4 
5 
Printing: 6 
7 
Printing: 8 
9 

दूसरे शब्दों में , next() अपेक्षित के रूप में काम कर रहा है, लेकिन क्योंकि यह इटैरेटर से अगला मान देता है, इंटरैक्टिव दुभाषिया द्वारा प्रतिबिंबित, आप के लिए नेतृत्व किया जाता है मान लें कि लूप की अपनी खुद की इटरेटर प्रतिलिपि है।

Answer 2

आपके पायथन/कंप्यूटर में कुछ गड़बड़ है।

a = iter(list(range(10))) 
for i in a: 
    print(i) 
    next(a) 

>>> 
0 
2 
4 
6 
8 

अपेक्षित काम करता है।

पायथन 2.7 और पायथन 3+ में परीक्षण किया गया। दोनों

Answer 3

क्या हो रहा है यह है कि next(a) कंसोल पर मुद्रित एक का अगला मान देता है क्योंकि यह प्रभावित नहीं होता है।क्योंकि वे केवल परोक्ष रूप से कोड उदाहरण में आवश्यक हैरानी बात का संकेत मिलता है

>>> a = iter(list(range(10))) 
>>> for i in a: 
... print(i) 
... b=next(a) 
... 
0 
2 
4 
6 
8 

Answer 4

मैं एक छोटे से भ्रामक मौजूदा जवाब मिल,:

आप क्या कर सकते हैं इस मूल्य के साथ एक चर को प्रभावित है दोनों * "प्रिंट I" और "अगला (ए)" उनके परिणाम मुद्रित किए जा रहे हैं।

चूंकि वे मूल अनुक्रम के वैकल्पिक तत्वों को प्रिंट कर रहे हैं, और यह अप्रत्याशित है कि "अगला (ए)" कथन प्रिंट हो रहा है, ऐसा प्रतीत होता है जैसे "प्रिंट i" कथन सभी मानों को प्रिंट कर रहा है।

उस प्रकाश में, यह अधिक स्पष्ट हो जाता है कि एक चर के लिए "अगला (ए)" के परिणाम को आवंटित करने से इसके परिणाम की छपाई को रोक दिया जाता है, ताकि केवल "i" लूप वैरिएबल को वैकल्पिक मान मुद्रित किया जा सके। इसी तरह, "प्रिंट" कथन को कुछ और विशिष्ट बनाते हैं, साथ ही साथ इसे असंबद्ध भी करते हैं।

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

सवालों के जवाब देने में बेवकूफ चीज सामान्य रूप से, उत्तर के बारे में स्पष्ट होने के बारे में स्पष्ट है। यह छद्म हो सकता है। एक बार जब आप उन्हें समझते हैं तो जवाबों की आलोचना करते हैं। यह दिलचस्प है ...

Answer 5

यह जिस तरह से आप चाहते हैं, तो एक समारोह के रूप में बुलाया बर्ताव करता है:

>>> def test(): 
...  a = iter(list(range(10))) 
...  for i in a: 
...   print(i) 
...   next(a) 
... 
>>> test() 
0 
2 
4 
6 
8