用Pythonic方式以交替方式合并两个列表的方法？

我有两个列表，其中第一个肯定比第二个多包含一个项目。我想知道最Python方式创建一个新列表，该列表的偶数索引值来自第一个列表，其奇数索引值来自第二个列表。

# example inputs
list1 = ['f', 'o', 'o']
list2 = ['hello', 'world']

# desired output
['f', 'hello', 'o', 'world', 'o']

这可行，但不是很漂亮：

list3 = []
while True:
    try:
        list3.append(list1.pop(0))
        list3.append(list2.pop(0))
    except IndexError:
        break

还有什么可以实现的呢？最Python化的方法是什么？

这是切片的一种方法：

>>> list1 = ['f', 'o', 'o']
>>> list2 = ['hello', 'world']
>>> result = [None]*(len(list1)+len(list2))
>>> result[::2] = list1
>>> result[1::2] = list2
>>> result
['f', 'hello', 'o', 'world', 'o']

在itertools文档中有一个配方：

from itertools import cycle, islice

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

编辑：

对于大于3的python版本：

from itertools import cycle, islice

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

这应该做您想要的：

>>> iters = [iter(list1), iter(list2)]
>>> print list(it.next() for it in itertools.cycle(iters))
['f', 'hello', 'o', 'world', 'o']

import itertools
print [x for x in itertools.chain.from_iterable(itertools.izip_longest(list1,list2)) if x]

我认为这是最Python化的方式。

如果没有itertools，并假设l1比l2长1个项目：

>>> sum(zip(l1, l2+[0]), ())[:-1]
('f', 'hello', 'o', 'world', 'o')

使用itertools并假设列表不包含None：

>>> filter(None, sum(itertools.izip_longest(l1, l2), ()))
('f', 'hello', 'o', 'world', 'o')

我知道问题要问的是两个清单，其中一个清单比另一个清单要多，但我想我会把这个清单发给其他可能找到这个问题的清单。

这是Duncan的解决方案，适用于两个不同大小的列表。

list1 = ['f', 'o', 'o', 'b', 'a', 'r']
list2 = ['hello', 'world']
num = min(len(list1), len(list2))
result = [None]*(num*2)
result[::2] = list1[:num]
result[1::2] = list2[:num]
result.extend(list1[num:])
result.extend(list2[num:])
result

输出：

['f', 'hello', 'o', 'world', 'o', 'b', 'a', 'r'] 

如果两个列表的长度相等，则可以执行以下操作：

[x for y in zip(list1, list2) for x in y]

由于第一个列表还有一个元素，因此可以事后添加：

[x for y in zip(list1, list2) for x in y] + [list1[-1]]

这是一个可以做到的：

list3 = [ item for pair in zip(list1, list2 + [0]) for item in pair][:-1]

def combine(list1, list2):
    lst = []
    len1 = len(list1)
    len2 = len(list2)

    for index in range( max(len1, len2) ):
        if index+1 <= len1:
            lst += [list1[index]]

        if index+1 <= len2:
            lst += [list2[index]]

    return lst

这是基于上述Carlos Valiente的贡献，并且可以选择替换多个项目的组并确保输出中存在所有项目：

A=["a","b","c","d"]
B=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]

def cyclemix(xs, ys, n=1):
    for p in range(0,int((len(ys)+len(xs))/n)):
        for g in range(0,min(len(ys),n)):
            yield ys[0]
            ys.append(ys.pop(0))
        for g in range(0,min(len(xs),n)):
            yield xs[0]
            xs.append(xs.pop(0))

print [x for x in cyclemix(A, B, 3)]

这将按3个值的组对列表A和B进行隔行扫描：

['a', 'b', 'c', 1, 2, 3, 'd', 'a', 'b', 4, 5, 6, 'c', 'd', 'a', 7, 8, 9, 'b', 'c', 'd', 10, 11, 12, 'a', 'b', 'c', 13, 14, 15]

我的看法：

a = "hlowrd"
b = "el ol"

def func(xs, ys):
    ys = iter(ys)
    for x in xs:
        yield x
        yield ys.next()

print [x for x in func(a, b)]

这是一个使用列表推导，不带其他库的衬板：

list3 = [sub[i] for i in range(len(list2)) for sub in [list1, list2]] + [list1[-1]]

如果允许通过副作用更改初始列表1，则这是另一种方法：

[list1.insert((i+1)*2-1, list2[i]) for i in range(len(list2))]

可能会晚一点再买另一条python单缸纸。当两个列表的大小相等或不相等时，此方法有效。一无是处的事情是它将修改a和b。如果有问题，则需要使用其他解决方案。

a = ['f', 'o', 'o']
b = ['hello', 'world']
sum([[a.pop(0), b.pop(0)] for i in range(min(len(a), len(b)))],[])+a+b
['f', 'hello', 'o', 'world', 'o']

from itertools import chain
list(chain(*zip('abc', 'def')))  # Note: this only works for lists of equal length
['a', 'd', 'b', 'e', 'c', 'f']

停在最短的位置：

def interlace(*iters, next = next) -> collections.Iterable:
    """
    interlace(i1, i2, ..., in) -> (
        i1-0, i2-0, ..., in-0,
        i1-1, i2-1, ..., in-1,
        .
        .
        .
        i1-n, i2-n, ..., in-n,
    )
    """
    return map(next, cycle([iter(x) for x in iters]))

当然，解决next / __ next__方法可能更快。

这很讨厌，但是不管列表的大小如何都可以：

list3 = [element for element in list(itertools.chain.from_iterable([val for val in itertools.izip_longest(list1, list2)])) if element != None]

多个单线从另一个问题的答案中得到启发：

import itertools

list(itertools.chain.from_iterable(itertools.izip_longest(list1, list2, fillvalue=object)))[:-1]

[i for l in itertools.izip_longest(list1, list2, fillvalue=object) for i in l if i is not object]

[item for sublist in map(None, list1, list2) for item in sublist][:-1]

numpy怎么样？它也适用于字符串：

import numpy as np

np.array([[a,b] for a,b in zip([1,2,3],[2,3,4,5,6])]).ravel()

结果：

array([1, 2, 2, 3, 3, 4])

一种功能不变的替代方法（Python 3）：

from itertools import zip_longest
from functools import reduce

reduce(lambda lst, zipped: [*lst, *zipped] if zipped[1] != None else [*lst, zipped[0]], zip_longest(list1, list2),[])

我会做简单的：

chain.from_iterable( izip( list1, list2 ) )

它将提供一个迭代器，而无需创建任何其他存储需求。

我太老了，无法接受列表理解，所以：

import operator
list3 = reduce(operator.add, zip(list1, list2))