blocks|key|1118298|text|iter()是序列上的迭代器。[x]+*+n生成一个包含n数量x的列表，即一个长度为n的列表，其中每个元素都是x。*arg将序列解压到函数调用的参数中。因此，您将向zip()传递相同的迭代器3次，并且每次都从迭代器中提取一个项目。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1118299|x+=+iter([1,2,3,4,5,6,7,8,9])
print+zip(x,+x,+x)|code-block|syntax|javascript|1118300|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/functions.html#iter|1|https://docs.python.org/2/library/functions.html#zip^0|0|6|F|7|S|1|V|1|16|1|1J|1|1L|4|2A|5|0|6|0|2A|5|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]]|E|$]]|$1|F|3|G|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

<a href="https://docs.python.org/2/library/functions.html#iter" rel="noreferrer"><code>iter()</code></a> is an iterator over a sequence. <code>[x] * n</code> produces a list containing <code>n</code> quantity of <code>x</code>, i.e. a list of length <code>n</code>, where each element is <code>x</code>. <code>*arg</code> unpacks a sequence into arguments for a function call. Therefore you're passing the same iterator 3 times to <a href="https://docs.python.org/2/library/functions.html#zip" rel="noreferrer"><code>zip()</code></a>, and it pulls an item from the iterator each time.

<pre><code>x = iter([1,2,3,4,5,6,7,8,9])
print zip(x, x, x)
</code></pre>

blocks|key|1118501|text|我认为在所有答案中遗漏了一件事(对于那些熟悉迭代器的人来说可能是显而易见的)，但对其他人来说不是那么明显的是-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1118502|因为我们有相同的迭代器，所以它被使用，其余的元素由zip使用。因此，如果我们只是使用列表而不是iter，例如。|1118503|l+=+range(9)
zip(*([l]*3))+#+note:+not+an+iter+here,+the+lists+are+not+emptied+as+we+iterate+
#+output+
[(0,+0,+0),+(1,+1,+1),+(2,+2,+2),+(3,+3,+3),+(4,+4,+4),+(5,+5,+5),+(6,+6,+6),+(7,+7,+7),+(8,+8,+8)]|code-block|syntax|javascript|1118504|使用迭代器，弹出值并保持可用，因此对于zip，一旦使用0，则1可用，然后是2，依此类推。一件非常微妙的事情，但相当聪明！|1118505|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think one thing that's missed in all the answers (probably obvious to those familiar with iterators) but not so obvious to others is - 

Since we have the same iterator, it gets consumed and the remaining elements are used by the zip. So if we simply used the list and not the iter 
eg.

<pre><code>l = range(9)
zip(*([l]*3)) # note: not an iter here, the lists are not emptied as we iterate 
# output 
[(0, 0, 0), (1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4), (5, 5, 5), (6, 6, 6), (7, 7, 7), (8, 8, 8)]
</code></pre>

Using iterator, pops the values and only keeps remaining available, so for zip once 0 is consumed 1 is available and then 2 and so on. A very subtle thing, but quite clever!!!

blocks|key|1118347|text|iter(s)返回s的迭代器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1118348|[iter(s)]*n生成一个n倍于s的相同迭代器的列表。|1118349|因此，在执行zip(*[iter(s)]*n)时，它会按顺序从列表中的所有三个迭代器中提取一项。因为所有迭代器都是同一个对象，所以它只是将列表分组为n块。|1118350|entityMap^0|0|7|0|0|B|0|6|H|22|1|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|K|$]]

<code>iter(s)</code> returns an iterator for s.

<code>[iter(s)]*n</code> makes a list of n times the same iterator for s.

So, when doing <code>zip(*[iter(s)]*n)</code>, it extracts an item from all the three iterators from the list in order. Since all the iterators are the same object, it just groups the list in chunks of <code>n</code>.

blocks|key|1333473|text|对于以这种方式使用zip，我有一个忠告。如果列表的长度不是均匀整除的，它将截断列表。要解决此问题，如果可以接受填充值，则可以使用itertools.izip_longest。或者你可以使用下面这样的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1333474|def+n_split(iterable,+n):
++++num_extra+=+len(iterable)+%25+n
++++zipped+=+zip(*[iter(iterable)]+*+n)
++++return+zipped+if+not+num_extra+else+zipped+%2B+[iterable[-num_extra:],+]|code-block|syntax|javascript|1333475|用法：|1333476|for+ints+in+n_split(range(1,12),+3):
++++print+',+'.join([str(i)+for+i+in+ints])|1333477|打印：|1333478|1,+2,+3
4,+5,+6
7,+8,+9
10,+11|1333479|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/2/library/itertools.html#itertools.izip_longest^0|1S|M|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

One word of advice for using zip this way. It will truncate your list if it's length is not evenly divisible. To work around this you could either use <a href="http://docs.python.org/2/library/itertools.html#itertools.izip_longest" rel="noreferrer">itertools.izip_longest</a> if you can accept fill values. Or you could use something like this:

<pre><code>def n_split(iterable, n):
 num_extra = len(iterable) % n
 zipped = zip(*[iter(iterable)] * n)
 return zipped if not num_extra else zipped + [iterable[-num_extra:], ]
</code></pre>

Usage:

<pre><code>for ints in n_split(range(1,12), 3):
 print ', '.join([str(i) for i in ints])
</code></pre>

Prints:

<pre><code>1, 2, 3
4, 5, 6
7, 8, 9
10, 11
</code></pre>

blocks|key|1118573|text|使用n+=+2来查看python解释器或ipython中发生的事情可能会更容易|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1118574|In+[35]:+[iter("ABCDEFGH")]*2
Out[35]:+[<iterator+at+0x6be4128>,+<iterator+at+0x6be4128>]|code-block|syntax|javascript|1118575|因此，我们有一个包含两个迭代器的列表，这两个迭代器指向同一个迭代器对象。请记住，对象上的iter返回一个迭代器对象，在此场景中，由于*2+python语法糖的原因，它是同一个迭代器两次。迭代器也只运行一次。|1118576|此外，zip接受任意数量的可迭代对象(sequences为iterables)，并从每个输入序列的第i个元素创建元组。因为在我们的例子中，两个迭代器是相同的，所以zip为输出的每个2元素元组移动相同的迭代器两次。|1118577|In+[41]:+help(zip)
Help+on+built-in+function+zip+in+module+__builtin__:

zip(...)
++++zip(seq1+[,+seq2+[...]])+->+[(seq1[0],+seq2[0]+...),+(...)]

++++Return+a+list+of+tuples,+where+each+tuple+contains+the+i-th+element
++++from+each+of+the+argument+sequences.++The+returned+list+is+truncated
++++in+length+to+the+length+of+the+shortest+argument+sequence.|1118578|unpacking+(*)+operator确保迭代器运行到耗尽，在本例中是直到没有足够的输入来创建2元素元组。|1118579|这可以扩展到所描述的n和zip(*[iter(s)]*n)作品的任何值。|1118580|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/functions.html#zip|1|https://docs.python.org/2/library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange|2|https://docs.python.org/2/library/stdtypes.html#iterator-types|3|https://stackoverflow.com/a/2322410/828885^0|2|5|K|7|0|0|18|4|1U|2|0|3|3|3|3|0|J|9|1|T|9|2|0|0|B|1|0|M|3|0|A|1|C|H|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@$9|1M|A|1N|1|1O]|$9|1P|A|1Q|1|1R]|$9|1S|A|1T|1|1U]]|E|$]]|$1|O|3|P|5|H|7|1V|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@$9|1Z|A|20|1|21]]|E|$]]|$1|S|3|T|5|6|7|22|8|@$9|23|A|24|B|C]|$9|25|A|26|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|27|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]|12|$5|X|Y|Z|E|$10|13]]|14|$5|X|Y|Z|E|$10|15]]|16|$5|X|Y|Z|E|$10|17]]]]

It is probably easier to see what is happening in python interpreter or <code>ipython</code> with <code>n = 2</code>:

<pre><code>In [35]: [iter("ABCDEFGH")]*2
Out[35]: [&lt;iterator at 0x6be4128&gt;, &lt;iterator at 0x6be4128&gt;]
</code></pre>

So, we have a list of two iterators which are pointing to the same iterator object. Remember that <code>iter</code> on a object returns an iterator object and in this scenario, it is the same iterator twice due to the <code>*2</code> python syntactic sugar. Iterators also run only once.

Further, <a href="https://docs.python.org/2/library/functions.html#zip" rel="nofollow noreferrer"><code>zip</code></a> takes any number of iterables (<a href="https://docs.python.org/2/library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange" rel="nofollow noreferrer">sequences</a> are <a href="https://docs.python.org/2/library/stdtypes.html#iterator-types" rel="nofollow noreferrer">iterables</a>) and creates tuple from i'th element of each of the input sequences. Since both iterators are identical in our case, zip moves the same iterator twice for each 2-element tuple of output.

<pre><code>In [41]: help(zip)
Help on built-in function zip in module __builtin__:

zip(...)
 zip(seq1 [, seq2 [...]]) -&gt; [(seq1[0], seq2[0] ...), (...)]

 Return a list of tuples, where each tuple contains the i-th element
 from each of the argument sequences. The returned list is truncated
 in length to the length of the shortest argument sequence.
</code></pre>

The <a href="https://stackoverflow.com/a/2322410/828885">unpacking (<code>*</code>) operator</a> ensures that the iterators run to exhaustion which in this case is until there is not enough input to create a 2-element tuple.

This can be extended to any value of <code>n</code> and <code>zip(*[iter(s)]*n)</code> works as described.

blocks|key|1333698|text|我需要分解每个部分步骤，以便真正内化它是如何工作的。我来自REPL的笔记：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1333699|>>>+#+refresher+on+using+list+multiples+to+repeat+item
>>>+lst+=+list(range(15))
>>>+lst
[0,+1,+2,+3,+4,+5,+6,+7,+8,+9,+10,+11,+12,+13,+14]
>>>+#+lst+id+value
>>>+id(lst)
139755081359872
>>>+[id(x)+for+x+in+[lst]*3]
[139755081359872,+139755081359872,+139755081359872]

#+replacing+lst+with+an+iterator+of+lst
#+It's+the+same+iterator+three+times
>>>+[id(x)+for+x+in+[iter(lst)]*3+]
[139755085005296,+139755085005296,+139755085005296]
#+without+starred+expression+zip+would+only+see+single+n-item+list.
>>>+print([iter(lst)]*3)
[<list_iterator+object+at+0x7f1b440837c0>,+<list_iterator+object+at+0x7f1b440837c0>,+<list_iterator+object+at+0x7f1b440837c0>]
#+Must+use+starred+expression+to+expand+n+arguments
>>>+print(*[iter(lst)]*3)
<list_iterator+object+at+0x7f1b4418b1f0>+<list_iterator+object+at+0x7f1b4418b1f0>+<list_iterator+object+at+0x7f1b4418b1f0>

#+by+repeating+the+same+iterator,+n-times,
#+each+pass+of+zip+will+call+the+same+iterator.__next__()+n+times
#+this+is+equivalent+to+manually+calling+__next__()+until+complete
>>>+iter_lst+=+iter(lst)
>>>+((iter_lst.__next__(),+iter_lst.__next__(),+iter_lst.__next__()))
(0,+1,+2)
>>>+((iter_lst.__next__(),+iter_lst.__next__(),+iter_lst.__next__()))
(3,+4,+5)
>>>+((iter_lst.__next__(),+iter_lst.__next__(),+iter_lst.__next__()))
(6,+7,+8)
>>>+((iter_lst.__next__(),+iter_lst.__next__(),+iter_lst.__next__()))
(9,+10,+11)
>>>+((iter_lst.__next__(),+iter_lst.__next__(),+iter_lst.__next__()))
(12,+13,+14)
>>>+((iter_lst.__next__(),+iter_lst.__next__(),+iter_lst.__next__()))
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
StopIteration

#+all+together+now!
#+continuing+with+same+iterator+multiple+times+in+list
>>>+print(*[iter(lst)]*3)
<list_iterator+object+at+0x7f1b4418b1f0>+<list_iterator+object+at+0x7f1b4418b1f0>+<list_iterator+object+at+0x7f1b4418b1f0>
>>>+zip(*[iter(lst)]*3)
<zip+object+at+0x7f1b43f14e00>
>>>+list(zip(*[iter(lst)]*3))
[(0,+1,+2),+(3,+4,+5),+(6,+7,+8),+(9,+10,+11),+(12,+13,+14)]

#+NOTE:+must+use+list+multiples.+Explicit+listing+creates+3+unique+iterators
>>>+[iter(lst)]*3+==+[iter(lst),+iter(lst),+iter(lst)]
False
>>>+list(zip(*[[iter(lst),+iter(lst),+iter(lst)]))
[(0,+0,+0),+(1,+1,+1),+(2,+2,+2),+(3,+3,+3),+....++++|code-block|syntax|javascript|1333700|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|$]]

I needed to break down each partial step to really internalize how it is working. My notes from the REPL:
<pre><code>&gt;&gt;&gt; # refresher on using list multiples to repeat item
&gt;&gt;&gt; lst = list(range(15))
&gt;&gt;&gt; lst
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
&gt;&gt;&gt; # lst id value
&gt;&gt;&gt; id(lst)
139755081359872
&gt;&gt;&gt; [id(x) for x in [lst]*3]
[139755081359872, 139755081359872, 139755081359872]

# replacing lst with an iterator of lst
# It's the same iterator three times
&gt;&gt;&gt; [id(x) for x in [iter(lst)]*3 ]
[139755085005296, 139755085005296, 139755085005296]
# without starred expression zip would only see single n-item list.
&gt;&gt;&gt; print([iter(lst)]*3)
[&lt;list_iterator object at 0x7f1b440837c0&gt;, &lt;list_iterator object at 0x7f1b440837c0&gt;, &lt;list_iterator object at 0x7f1b440837c0&gt;]
# Must use starred expression to expand n arguments
&gt;&gt;&gt; print(*[iter(lst)]*3)
&lt;list_iterator object at 0x7f1b4418b1f0&gt; &lt;list_iterator object at 0x7f1b4418b1f0&gt; &lt;list_iterator object at 0x7f1b4418b1f0&gt;

# by repeating the same iterator, n-times,
# each pass of zip will call the same iterator.__next__() n times
# this is equivalent to manually calling __next__() until complete
&gt;&gt;&gt; iter_lst = iter(lst)
&gt;&gt;&gt; ((iter_lst.__next__(), iter_lst.__next__(), iter_lst.__next__()))
(0, 1, 2)
&gt;&gt;&gt; ((iter_lst.__next__(), iter_lst.__next__(), iter_lst.__next__()))
(3, 4, 5)
&gt;&gt;&gt; ((iter_lst.__next__(), iter_lst.__next__(), iter_lst.__next__()))
(6, 7, 8)
&gt;&gt;&gt; ((iter_lst.__next__(), iter_lst.__next__(), iter_lst.__next__()))
(9, 10, 11)
&gt;&gt;&gt; ((iter_lst.__next__(), iter_lst.__next__(), iter_lst.__next__()))
(12, 13, 14)
&gt;&gt;&gt; ((iter_lst.__next__(), iter_lst.__next__(), iter_lst.__next__()))
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
StopIteration

# all together now!
# continuing with same iterator multiple times in list
&gt;&gt;&gt; print(*[iter(lst)]*3)
&lt;list_iterator object at 0x7f1b4418b1f0&gt; &lt;list_iterator object at 0x7f1b4418b1f0&gt; &lt;list_iterator object at 0x7f1b4418b1f0&gt;
&gt;&gt;&gt; zip(*[iter(lst)]*3)
&lt;zip object at 0x7f1b43f14e00&gt;
&gt;&gt;&gt; list(zip(*[iter(lst)]*3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 14)]

# NOTE: must use list multiples. Explicit listing creates 3 unique iterators
&gt;&gt;&gt; [iter(lst)]*3 == [iter(lst), iter(lst), iter(lst)]
False
&gt;&gt;&gt; list(zip(*[[iter(lst), iter(lst), iter(lst)]))
[(0, 0, 0), (1, 1, 1), (2, 2, 2), (3, 3, 3), .... 
</code></pre>

<pre><code>s = [1,2,3,4,5,6,7,8,9]
n = 3

zip(*[iter(s)]*n) # returns [(1,2,3),(4,5,6),(7,8,9)]
</code></pre>

How does <code>zip(*[iter(s)]*n)</code> work? What would it look like if it was written with more verbose code?

How does zip(*[iter(s)]*n) work in Python?

解释器

s = [1,2,3,4,5,6,7,8,9]n = 3zip(*[iter(s)]*n) # returns [(1,2,3),(4,5,6),(7,8,9)]zip(*[iter(s)]*n)是如何工作的？如果它是用更冗长的代码编写的，它看起来会是什么样子？

问zip([iter(s)]n)在Python中是如何工作的？
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问zip(*[iter(s)]*n)在Python中是如何工作的？EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问zip([iter(s)]n)在Python中是如何工作的？
EN