blocks|key|1911567|text|您的Python/计算机有问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1911568|a+=+iter(list(range(10)))
for+i+in+a:
+++print(i)
+++next(a)

>>>+
0
2
4
6
8|code-block|syntax|javascript|1911569|如预期的那样工作。|1911570|在Python2.7和Python+3%2B中测试。在两者中都能正常工作|1911571|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Something is wrong with your Python/Computer.

<pre><code>a = iter(list(range(10)))
for i in a:
 print(i)
 next(a)

&gt;&gt;&gt; 
0
2
4
6
8
</code></pre>

Works like expected. 

Tested in Python 2.7 and in Python 3+ . Works properly in both

blocks|key|1698372|text|您所看到的是解释器回显next()的返回值，以及在每次迭代中打印i：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1698373|>>>+a+=+iter(list(range(10)))
>>>+for+i+in+a:
...++++print(i)
...++++next(a)
...+
0
1
2
3
4
5
6
7
8
9|code-block|syntax|javascript|1698374|所以0是print(i)的输出，1是next()的返回值，由交互式解释器回显，等等。只有5次迭代，每次迭代导致2行被写入终端。|1698375|如果您指定next()的输出，事情就会按预期运行：|1698376|>>>+a+=+iter(list(range(10)))
>>>+for+i+in+a:
...++++print(i)
...++++_+=+next(a)
...+
0
2
4
6
8|1698377|或者打印额外的信息，以区分print()输出和交互式解释器回显：|1698378|>>>+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|1698379|换句话说，next()按预期工作，但因为它返回迭代器的下一个值，并由交互式解释器响应，所以您会认为循环以某种方式拥有自己的迭代器副本。|1698380|entityMap^0|B|6|W|1|0|0|2|1|4|8|G|1|I|6|0|5|6|0|0|D|7|0|0|5|6|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|X|$]]

What you see is the interpreter echoing back the return value of <code>next()</code> in addition to <code>i</code> being printed each iteration:

<pre><code>&gt;&gt;&gt; a = iter(list(range(10)))
&gt;&gt;&gt; for i in a:
... print(i)
... next(a)
... 
0
1
2
3
4
5
6
7
8
9
</code></pre>

So <code>0</code> is the output of <code>print(i)</code>, <code>1</code> the return value from <code>next()</code>, echoed by the interactive interpreter, etc. There are just 5 iterations, each iteration resulting in 2 lines being written to the terminal.

If you assign the output of <code>next()</code> things work as expected:

<pre><code>&gt;&gt;&gt; a = iter(list(range(10)))
&gt;&gt;&gt; for i in a:
... print(i)
... _ = next(a)
... 
0
2
4
6
8
</code></pre>

or print extra information to differentiate the <code>print()</code> output from the interactive interpreter echo:

<pre><code>&gt;&gt;&gt; a = iter(list(range(10)))
&gt;&gt;&gt; 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
</code></pre>

In other words, <code>next()</code> is working as expected, but because it returns the next value from the iterator, echoed by the interactive interpreter, you are led to believe that the loop has its own iterator copy somehow.

blocks|key|1698410|text|发生的情况是，next(a)返回a的下一个值，该值被打印到控制台，因为它不受影响。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1698411|你能做的就是用这个值来影响一个变量：|1698412|>>>+a+=+iter(list(range(10)))
>>>+for+i+in+a:
...++++print(i)
...++++b=next(a)
...
0
2
4
6
8|code-block|syntax|javascript|1698413|entityMap^0|7|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

What is happening is that <code>next(a)</code> returns the next value of a, which is printed to the console because it is not affected.

What you can do is affect a variable with this value:

<pre><code>&gt;&gt;&gt; a = iter(list(range(10)))
&gt;&gt;&gt; for i in a:
... print(i)
... b=next(a)
...
0
2
4
6
8
</code></pre>

blocks|key|1912049|text|我发现现有的答案有点令人困惑，因为它们只间接地指出了代码示例中令人费解的本质："print+i“和"next(a)”都会导致打印其结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1912050|由于它们打印的是原始序列的交替元素，并且"next(a)“语句正在打印，因此看起来"print+i”语句正在打印所有的值。|1912051|从这个角度来看，将"next(a)“的结果赋值给一个变量会禁止打印它的结果，因此只打印"i”循环变量的替换值。同样，让"print“语句发出更独特的东西也可以消除歧义。|1912052|(其中一个现有答案反驳了其他答案，因为该答案将示例代码计算为一个块，因此解释器不会报告“next(A)”的中间值。)|1912053|一般来说，回答问题的诱人之处在于，一旦你知道了答案，你就会清楚地知道什么是显而易见的。它可能是难以捉摸的。同样地，一旦你理解了答案，就对它们进行评论。很有趣..。|1912054|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

I find the existing answers a little confusing, because they only indirectly indicate the essential mystifying thing in the code example: both* the "print i" and the "next(a)" are causing their results to be printed.

Since they're printing alternating elements of the original sequence, and it's unexpected that the "next(a)" statement is printing, it appears as if the "print i" statement is printing all the values.

In that light, it becomes more clear that assigning the result of "next(a)" to a variable inhibits the printing of its' result, so that just the alternate values that the "i" loop variable are printed. Similarly, making the "print" statement emit something more distinctive disambiguates it, as well.

(One of the existing answers refutes the others because that answer is having the example code evaluated as a block, so that the interpreter is not reporting the intermediate values for "next(a)".)

The beguiling thing in answering questions, in general, is being explicit about what is obvious once you know the answer. It can be elusive. Likewise critiquing answers once you understand them. It's interesting...

blocks|key|1698509|text|如果作为函数调用，它的行为方式是您想要的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1698510|>>>+def+test():
...+++++a+=+iter(list(range(10)))
...+++++for+i+in+a:
...+++++++++print(i)
...+++++++++next(a)
...+
>>>+test()
0
2
4
6
8|code-block|syntax|javascript|1698511|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It behaves the way you want if called as a function:

<pre><code>&gt;&gt;&gt; def test():
... a = iter(list(range(10)))
... for i in a:
... print(i)
... next(a)
... 
&gt;&gt;&gt; test()
0
2
4
6
8
</code></pre>

blocks|key|1698595|text|对于那些仍然不理解的人。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1698596|>>>+a+=+iter(list(range(10)))
>>>+for+i+in+a:
...++++print(i)
...++++next(a)
...+
0+#+print(i)+printed+this
1+#+next(a)+printed+this
2+#+print(i)+printed+this
3+#+next(a)+printed+this
4+#+print(i)+printed+this
5+#+next(a)+printed+this
6+#+print(i)+printed+this
7+#+next(a)+printed+this
8+#+print(i)+printed+this
9+#+next(a)+printed+this|code-block|syntax|javascript|1698597|正如其他人已经说过的那样，next如预期的那样将迭代器增加1。将其返回值赋给一个变量并不会神奇地改变它的行为。|offset|length|style|CODE|1698598|entityMap^0|0|0|D|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

For those who still do not understand.

<pre><code>&gt;&gt;&gt; a = iter(list(range(10)))
&gt;&gt;&gt; for i in a:
... print(i)
... next(a)
... 
0 # print(i) printed this
1 # next(a) printed this
2 # print(i) printed this
3 # next(a) printed this
4 # print(i) printed this
5 # next(a) printed this
6 # print(i) printed this
7 # next(a) printed this
8 # print(i) printed this
9 # next(a) printed this
</code></pre>

As others have already said, <code>next</code> increases the iterator by 1 as expected. Assigning its returned value to a variable doesn't magically changes its behaviour.

Consider:

<pre><code>&gt;&gt;&gt; lst = iter([1,2,3])
&gt;&gt;&gt; next(lst)
1
&gt;&gt;&gt; next(lst)
2
</code></pre>

So, advancing the iterator is, as expected, handled by mutating that same object. 

This being the case, I would expect:

<pre><code>a = iter(list(range(10)))
for i in a:
 print(i)
 next(a)
</code></pre>

to skip every second element: the call to <code>next</code> should advance the iterator once, then the implicit call made by the loop should advance it a second time - and the result of this second call would be assigned to <code>i</code>. 

It doesn't. The loop prints all of the items in the list, without skipping any. 

My first thought was that this might happen because the loop calls <code>iter</code> on what it is passed, and this might give an independent iterator - this isn't the case, as we have <code>iter(a) is a</code>. 

So, why does <code>next</code> not appear to advance the iterator in this case?

Python list iterator behavior and next(iterator)

解释器

Python

考虑一下：>>> lst = iter([1,2,3])>>> next(lst)1>>> next(lst)2因此，正如预期的那样，推进迭代器是通过改变同一个对象来处理的。在这种情况下，我希望：a = iter(list(range(10)))for i in a:   print(i)   next(a)跳过第二个...

问Python列表迭代器行为和next(迭代器)
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python列表迭代器行为和next(迭代器)EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python列表迭代器行为和next(迭代器)
EN