产生两个列表的交替值的生成器 function

Question

The question seems very basic and easy at first glance, but I still had some trouble writing an efficient solution. The idea is to write a function, which takes two generators as an input and yields one item of each list. If either list is empty, it yields each item of the remaining list. Example:

 list(alternate("abcdefg", [1, 2, 3, 4])) == ["a", 1, "b",2, "c", 3, "d", 4, "e", "f", "g"]

what kind of worked, but looks very ugly:

def alternate(xs1, xs2):
    xs1 = iter(xs1)
    xs2 = iter(xs2)
    while xs1 and xs2:
        try:
            yield next(xs1), next(xs2)
        except StopIteration:
                for x1 in xs1:
                    yield x1
                for x2 in xs2:
                    yield x2

Especially I want to avoid transforming the inputs to an iterator in the beginning. I tried using 2 simple for loops, but this obviously returned only the last value of each list, because one for loops finishes before the other starts. This is not a solve my problem question, I am rather looking for some code to improve writing code skills!

Answer 1

Use zip_longest and chain.from_iterable together:

>>> from itertools import chain, zip_longest
>>> [ x for x in chain.from_iterable(zip_longest("abcdefg", [1,2,3,4])) if x is not None]
['a', 1, 'b', 2, 'c', 3, 'd', 4, 'e', 'f', 'g']

For something more explicit and similar to what you already have, handle each call to next separately, and break out of the loop immediately to iterate over the remainder of each iterator. Use itertools.cycle to alternate between the two iterators until one is exhausted.

from itertools import cycle

def alternate(xs1, xs2):
    xs1 = iter(xs1)
    xs2 = iter(xs2)
    for itr in cycle([xs1, xs2]):
        try:
            yield next(itr)
        except StopIteration:
            break

    yield from xs1
    yield from xs2

Answer 2

I prefer the above answer but here's a version that doesn't use any imports:

def alternate(xs1, xs2):
    xs1, xs2 = iter(xs1), iter(xs2)
    for e1, e2 in zip(xs1, xs2): # either xs1, xs2 exhausted by the end of this loop
        yield e1
        yield e2
    
    # pull remaining from the non-exhausted generator (if any)
    yield from xs1
    yield from xs2

If you want a version that doesn't transform the inputs into iterators and avoids using other libraries, the below would work, assuming both sequences are indexable.

def alternate2(xs1, xs2):
    n = min(len(xs1), len(xs2))
    for i in range(n):
        yield xs1[i]
        yield xs2[i]
    
    yield from xs1[n:]
    yield from xs2[n:]

Answer 3

It's going to be challenging to do away with iter() , as that's kind of what it's made for. If you can put up with that, this can be straightforward:

def alternate(a, b):
    ia = iter(a)
    ib = iter(b)
    
    while True:
        try:
            yield next(ia)
            yield next(ib)
        except StopIteration:
            break
            
    yield from ia
    yield from ib

1. Just try to yield the next item from each of the items in turn.
2. Once one of them is empty, yield the rest.

Answer 4

This is slightly simpler than @wLui's:

def alternate(xs1, xs2):
     xs1 = iter(xs1)
     xs2 = iter(xs2)
     for pair in zip(xs1, xs2):
         yield from pair
     yield from xs1
     yield from xs2

Answer 5

(This is basically @chepner's answer from the comments, but I believe this is the right answer which deserves to appear here...)

You can use the roundrobin function from the more-itertools project (referenced from python docs ).

I include it here for convenience:

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    # Recipe credited to George Sakkis
    num_active = len(iterables)
    nexts = cycle(iter(it).__next__ for it in iterables)
    while num_active:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            # Remove the iterator we just exhausted from the cycle.
            num_active -= 1
            nexts = cycle(islice(nexts, num_active))