我有

a = [1, 2]

b = ['a', 'b']

我想要

c = [1, 'a', 2, 'b']

号

@cdleary's answer stackoverflow.com/questions/406121/&hellip；为"在python中扁平化一个浅列表"的各种方法提供性能比较(扁平化zip(a,b)为您提供了答案)。

[j for i in zip(a,b) for j in i]

。

它是有效的，但我不能在头脑中分析它…

[J代表J代表I，I代表I代表Zip(A，B)]尽管在我的头脑中更容易解析并不管用！

一开始读起来确实很奇怪：(1)精神上切掉第一个for的所有东西，把它移到最后，然后读到：for i in zip(a, b)、for j in i、j。

啊……整洁！谢谢。

整洁，但如果一个列表比另一个短1个元素(仍然应该能够合并)，则不起作用。

为什么不对列表使用串联：result=a+b。这也是你能读到的！

@拉尔夫，这取决于您的订购要求。

@约翰洛伊，没错。没有提到顺序和重复；)如果顺序起作用，那么我会说，用mark的itertool链这个例子是很好的。顺便说一句，通过set()可以避免重复。

如果元素的顺序与示例中的顺序非常匹配，则可以使用zip和chain的组合：

from itertools import chain

c = list(chain(*zip(a,b)))

如果您不关心结果中元素的顺序，那么有一种更简单的方法：

c = a + b

号

在我的例子中使用这个："c=a+b"->列表是不可重复的。那么呢？只有Chain可以检查我的问题以了解我的问题："stackoverflow.com/questions/40952892/&hellip；"

对于索引，datas.iterrows()中的行：textf=re.findall('f(.*？)}}"，row['review'])matrixf+=textf如果index==3:break for index in matrixf:print index，它仍然有效，所以我认为它仍然是不可更改的？"。

有一条链，来自于"Iterable:EDOCX1"(0)，这是一种非常懒惰的方式。

正在分析

[j for i in zip(a,b) for j in i]

。

如果你记得for和if条款是按顺序完成的，然后是结果的最后一个附加，那么在你的头脑中就足够容易了：

temp = []

for i in zip(a, b):

for j in i:

temp.append(j)

。

如果它是用更有意义的变量名来写的话会更容易些：

[item for pair in zip(a, b) for item in pair]

。

我通常对Les很满意，但是这个双循环让我很困惑。谢谢你的解释。

另一种方法是使用索引切片，结果发现它比Zip更快，扩展性更好：

def slicezip(a, b):

result = [0]*(len(a)+len(b))

result[::2] = a

result[1::2] = b

return result

您会注意到，这只在len(a) == len(b)的情况下有效，但是使用模拟zip的条件不能用a或b进行缩放。

进行比较：

a = range(100)

b = range(100)

%timeit [j for i in zip(a,b) for j in i]

100000 loops, best of 3: 15.4 μs per loop

%timeit list(chain(*zip(a,b)))

100000 loops, best of 3: 11.9 μs per loop

%timeit slicezip(a,b)

100000 loops, best of 3: 2.76 μs per loop

。

您所说的"将条件模拟为zip，而不是使用a或b进行缩放"是什么意思？

我的意思是，使用zip，如果一个列表比另一个长，那么较长的列表会被截断，以便与较短的列表合并。我们可以通过比较每个数组的长度，然后只分配较长数组的缩短版本来实现这一点。如果数组变大，那么对长度和截断的检查就不再需要花费时间了。

注：这对于有利于第一个列表的平分目的很有效：它允许长度相同或比第二个slicezip([1,2,3],[4,5])长一个，这意味着在这种情况下，您不必处理不均匀的列表(这非常好)。

如果您关心订单：

#import operator

import itertools

a = [1,2]

b = ['a','b']

#c = list(reduce(operator.add,zip(a,b))) # slow.

c = list(itertools.chain.from_iterable(zip(a,b))) # better.

print c给[1, 'a', 2, 'b']。

-1表示二次时间。你可以在线性时间内做到这一点。

@阿龙·加拉赫修好了，但还是有一个(巧妙地)独特的答案。

这里有一个标准/自我解释的解决方案，我希望有人会发现它有用：

a = ['a', 'b', 'c']

b = ['1', '2', '3']

c = []

for x, y in zip(a, b):

c.append(x)

c.append(y)

print (c)

号

输出：

['a', '1', 'b', '2', 'c', '3']

号

当然，如果需要，您可以更改它并对值进行操作。

def main():

drinks = ["Johnnie Walker","Jose Cuervo","Jim Beam","Jack Daniels,"]

booze = [1, 2, 3, 4, 5]

num_drinks = []

x = 0

for i in booze:

if x < len(drinks):

num_drinks.append(drinks[x])

num_drinks.append(booze[x])

x += 1

else:

print(num_drinks)

return

主体()

请你解释一下你的答案。

5轮后你有没有想出这个答案？

c = []

c.extend(a)

c.extend(b)

。

期望的结果完全不同。

虽然这段代码可以回答这个问题，但是提供关于如何和/或为什么解决这个问题的额外上下文将提高答案的长期价值。

如果它回答了问题，并且与所有其他答案不同，为什么不支持它呢？我相信这个问题没有太多的背景，所以任何相关的答案都是受欢迎的。