Как объединить два итератора 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

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

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

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

Answer 3

Я также согласен с тем, что 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 4

Я бы сделал что-то вроде этого. Это будет наиболее эффективным с точки зрения времени и пространства, так как вам не придется загружать объекты вместе. Это также будет работать, если оба 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 5

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

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

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

Я предпочитаю другой способ, который гораздо более лаконичен:

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

Answer 8

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

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

Answer 9

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

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

Answer 10

Используйте 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 11

Зачем нужны itertools?

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

В этом случае хотя бы один из элементов a или b должен иметь конечную длину, поскольку zip вернет список, а не итератор. Если вам нужен итератор в качестве вывода, тогда вы можете перейти к решению Claudiu.

Answer 12

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

As " pydoc itertools.izip " показывает: " работает как функция zip (), но потребляет меньше памяти, возвращая итератор вместо списка. "

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

Answer 13

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

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