Как работает zip (* [iter (s)] * n) в Python?

Question

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)]

Как работает zip(*[iter(s)]*n)? Как бы это выглядело, если бы оно было написано с большим количеством подробного кода?

Answer 1

iter() - итератор последовательности. [x] * n создает список, содержащий n количество x, то есть список длиной n, где каждый элемент равен x. *arg распаковывает последовательность в аргументы для вызова функции. Поэтому вы передаете один и тот же итератор 3 раза zip(), и он каждый раз получает элемент из итератора.

x = iter([1,2,3,4,5,6,7,8,9])
print zip(x, x, x)

Answer 2

Другие замечательные ответы и комментарии хорошо объясняют роли распаковки аргументов и zip () .

Как говорят Игнасио и ujukatzel , вы передаете zip() три ссылки на один и тот же итератор, а zip() составляет 3 кортежа целых чисел - по порядку - из каждого ссылка на итератор:

1,2,3,4,5,6,7,8,9  1,2,3,4,5,6,7,8,9  1,2,3,4,5,6,7,8,9
^                    ^                    ^            
      ^                    ^                    ^
            ^                    ^                    ^

А так как вы просите более подробный пример кода:

chunk_size = 3
L = [1,2,3,4,5,6,7,8,9]

# iterate over L in steps of 3
for start in range(0,len(L),chunk_size): # xrange() in 2.x; range() in 3.x
    end = start + chunk_size
    print L[start:end] # three-item chunks

После значений start и end:

[0:3) #[1,2,3]
[3:6) #[4,5,6]
[6:9) #[7,8,9]

FWIW, вы можете получить тот же результат с map() с начальным аргументом None:

>>> map(None,*[iter(s)]*3)
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]

Подробнее о zip() и map(): http://muffinresearch.co.uk/archives/2007/10/16/python-transposing-lists-with-map-and-zip/

Answer 3

Я думаю, что одна вещь, которая пропущена во всех ответах (вероятно, очевидна для тех, кто знаком с итераторами), но не так очевидна для других, -

Поскольку у нас один и тот же итератор, он расходуется, а остальные элементы используются в zip. Так что, если мы просто использовали список, а не iter например.

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)]

Используя итератор, извлекает значения и сохраняет только доступность, поэтому для zip, когда 0 используется, 1 доступно, затем 2 и так далее. Очень тонкая вещь, но довольно умная !!!

Answer 4

iter(s) возвращает итератор для s.

[iter(s)]*n составляет список из n раз одного итератора для s.

Итак, при выполнении zip(*[iter(s)]*n) он извлекает элемент из всех трех итераторов из списка по порядку. Поскольку все итераторы являются одним и тем же объектом, он просто группирует список по частям n.

Answer 5

Один совет для использования zip таким способом. Он будет урезать ваш список, если его длина не делится поровну. Чтобы обойти это, вы можете использовать itertools.izip_longest , если вы можете принимать значения заполнения. Или вы можете использовать что-то вроде этого:

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:], ]

Использование:

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

Печать:

1, 2, 3
4, 5, 6
7, 8, 9
10, 11

Answer 6

Вероятно, легче увидеть, что происходит в интерпретаторе Python или ipython с n = 2:

In [35]: [iter("ABCDEFGH")]*2
Out[35]: [<iterator at 0x6be4128>, <iterator at 0x6be4128>]

Итак, у нас есть список из двух итераторов, которые указывают на один и тот же объект итератора. Помните, что iter для объекта возвращает объект итератора, и в этом сценарии это один и тот же итератор дважды из-за синтаксического сахара *2 python. Итераторы также запускаются только один раз.

Далее, zip принимает любое количество итераций ( последовательности являются итерациями ) и создает кортеж из i-го элемента каждой из входных последовательностей , Поскольку в нашем случае оба итератора идентичны, zip перемещает один и тот же итератор дважды для каждого двухэлементного набора вывода.

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.

Оператор распаковки (*) гарантирует, что итераторы работают до предела, что в этом случае происходит до тех пор, пока не будет достаточно входных данных для создания кортежа из 2 элементов.

Это может быть расширено до любого значения n, и zip(*[iter(s)]*n) работает как описано.