Как слить два итератора python?

Question

У меня есть два итератора, list и объект itertools.count (т. Е. Генератор бесконечного значения). Я хотел бы объединить эти два в результате итератор, который будет чередовать значения доходности между ними:

>>> import itertools 
>>> c = itertools.count(1) 
>>> items = ['foo', 'bar'] 
>>> merged = imerge(items, c) # the mythical "imerge" 
>>> merged.next() 
'foo' 
>>> merged.next() 
1 
>>> merged.next() 
'bar' 
>>> merged.next() 
2 
>>> merged.next() 
Traceback (most recent call last): 
    ... 
StopIteration 

Что является самым простым, самым кратким способом сделать это?

Answer 1

Генератор решит вашу проблему красиво.

def imerge(a, b): 
    for i, j in itertools.izip(a,b): 
     yield i 
     yield j 

Answer 2

Я бы сделал что-то подобное. Это будет наиболее эффективным временем и пространством, так как у вас не будет накладных расходов на скрепление объектов. Это также будет работать, если оба a и b бесконечны.

def imerge(a, b): 
    i1 = iter(a) 
    i2 = iter(b) 
    while True: 
     try: 
      yield i1.next() 
      yield i2.next() 
     except StopIteration: 
      return 

Answer 3

Вы можете использовать zip, а также itertools.chain. Это будет работать только , если первый список конечное:

merge=itertools.chain(*[iter(i) for i in zip(['foo', 'bar'], itertools.count(1))]) 

Answer 4

Вы можете сделать что-то, что почти exaclty, что @Pramod первым предложил.

def izipmerge(a, b): 
    for i, j in itertools.izip(a,b): 
    yield i 
    yield j 

Преимущество этого подхода заключается в том, что вы не исчерпали память, если оба a и b бесконечны.

Answer 5

Для чего нужен itertools?

def imerge(a,b): 
    for i,j in zip(a,b): 
     yield i 
     yield j 

В этом случае, по меньшей мере, один из А или Б должна быть конечной длины, потому что застежка-молния будет возвращать список, а не итератора. Если вам нужен итератор в качестве вывода, вы можете пойти на решение Claudiu.

Answer 6

Я не уверен, что ваше приложение, но вы можете найти функцию enumerate() более полезной.

>>> items = ['foo', 'bar', 'baz'] 
>>> for i, item in enumerate(items): 
... print item 
... print i 
... 
foo 
0 
bar 
1 
baz 
2 

Answer 7

Я также согласен с тем, что itertools не требуется.

Но зачем останавливаться на 2?

def tmerge(*iterators): 
    for values in zip(*iterators): 
     for value in values: 
     yield value 

обрабатывает любое количество итераторов от 0 до.

ОБНОВЛЕНИЕ: DOH! Один из комментаторов отметил, что это не сработает, если все итераторы не будут иметь одинаковую длину.

Правильный код:

def tmerge(*iterators): 
    empty = {} 
    for values in itertools.izip_longest(*iterators, fillvalue=empty): 
    for value in values: 
     if value is not empty: 
     yield value 

и да, я просто попытался его со списками разной длины, а также список, содержащий {}.

Answer 8

Использование itertools.izip(), вместо того, чтобы молнии(), как и в некоторых других ответов, улучшит производительность:

Как «pydoc itertools.izip» показывает: «Работает как функции почтового индекса(), но потребляет меньше памяти, возвращая итератор вместо списка ».

Itertools.izip также будет работать правильно, даже если один из итераторов бесконечен.

Answer 9

Используйте izip и цепь вместе:

>>> list(itertools.chain.from_iterable(itertools.izip(items, c))) # 2.6 only 
['foo', 1, 'bar', 2] 

>>> list(itertools.chain(*itertools.izip(items, c))) 
['foo', 1, 'bar', 2] 

Answer 10

Краткий способ заключается в использовании выражения генератора с itertools.cycle(). Он избегает создания длинной цепочки() кортежей.

generator = (it.next() for it in itertools.cycle([i1, i2])) 

Answer 11

Я предпочитаю этот другой путь, который является гораздо более кратким:

iter = reduce(lambda x,y: itertools.chain(x,y), iters) 

Answer 12

Одним из менее известных особенностей Python является то, что вы можете иметь больше для пунктов в выражении генератора. Очень полезно для сглаживания вложенных списков, например, из zip()/izip().

def imerge(*iterators): 
    return (value for row in itertools.izip(*iterators) for value in row) 

Answer 13

Вот элегантное решение:

def alternate(*iterators): 
    while len(iterators) > 0: 
     try: 
      yield next(iterators[0]) 
      # Move this iterator to the back of the queue 
      iterators = iterators[1:] + iterators[:1] 
     except StopIteration: 
      # Remove this iterator from the queue completely 
      iterators = iterators[1:] 

Использование фактической очереди для лучшей производительности (как это было предложено Давида):

from collections import deque 

def alternate(*iterators): 
    queue = deque(iterators) 
    while len(queue) > 0: 
     iterator = queue.popleft() 
     try: 
      yield next(iterator) 
      queue.append(iterator) 
     except StopIteration: 
      pass 

Он работает даже тогда, когда некоторые итераторы конечны и другие являются бесконечными:

from itertools import count 

for n in alternate(count(), iter(range(3)), count(100)): 
    input(n) 

печать:

0 
0 
100 
1 
1 
101 
2 
2 
102 
3 
103 
4 
104 
5 
105 
6 
106 

Он также корректно останавливается, если/когда все итераторы были исчерпаны.

Если вы хотите обрабатывать без итераторов итерируемых, как списки, вы можете использовать

def alternate(*iterables): 
    queue = deque(map(iter, iterables)) 
    ...