В Python есть ли хороший способ чередования двух списков одной длины?
Скажем, мне дали [1,2,3] и [10,20,30]. Я хотел бы преобразовать их в [1,10,2,20,3,30].
Разместив вопрос, я понял, что могу просто сделать следующее:
[val for pair in zip(l1, l2) for val in pair]
где l1 и l2 - два списка.
Если есть N списков для чередования, то
lists = [l1, l2, ...]
[val for tup in zip(*lists) for val in tup]
Для большего количества рецептов следуйте Лучшему способу чередовать список с его значениями суффикса. Некоторые из продемонстрированных здесь методов можно обобщить до двух или более списков одинаковой длины.
Для Python> = 2.3 существует расширенный синтаксис слайса:
>>> a = [0, 2, 4, 6, 8]
>>> b = [1, 3, 5, 7, 9]
>>> c = a + b
>>> c[::2] = a
>>> c[1::2] = b
>>> c
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Строка c = a + b используется как простой способ создания нового списка точно правильной длины (на данном этапе его содержимое не имеет значения). Следующие две строки выполняют фактическую работу по чередованию a и b: первая назначает элементы a всем четным индексам c; второй присваивает элементы b всем нечетным индексам c.
Дано
a = [1, 2, 3]
b = [10, 20, 30]
c = [100, 200, 300, 999]
Код
Предполагая списки одинаковой длины, вы можете получить чередующийся список с помощью itertools.chain и zip:
import itertools
list(itertools.chain(*zip(a, b)))
# [1, 10, 2, 20, 3, 30]
альтернативы
В более общем случае с неравными списками используйте zip_longest (рекомендуется):
[x for x in itertools.chain(*itertools.zip_longest(a, c)) if x is not None]
# [1, 100, 2, 200, 3, 300, 999]
Многие списки можно безопасно чередовать:
[x for x in itertools.chain(*itertools.zip_longest(a, b, c)) if x is not None]
# [1, 10, 100, 2, 20, 200, 3, 30, 300, 999]
Библиотека, которая поставляется с roundrobin roundrobin itertools, interleave и interleave_longest.
import more_itertools
list(more_itertools.roundrobin(a, b))
# [1, 10, 2, 20, 3, 30]
list(more_itertools.interleave(a, b))
# [1, 10, 2, 20, 3, 30]
list(more_itertools.interleave_longest(a, c))
# [1, 100, 2, 200, 3, 300, 999]
yield from
Наконец, кое-что интересное в Python 3 (хотя и не рекомендуется):
list(filter(None, ((yield from x) for x in zip(a, b))))
# [1, 10, 2, 20, 3, 30]
list([(yield from x) for x in zip(a, b)])
# [1, 10, 2, 20, 3, 30]
+ Установить с помощью pip install more_itertools
Альтернатива:
>>> l1=[1,2,3]
>>> l2=[10,20,30]
>>> [y for x in map(None,l1,l2) for y in x if y is not None]
[1, 10, 2, 20, 3, 30]
Это работает, потому что карта работает со списками параллельно. Он работает так же под 2.2. Само по себе, с None в качестве вызываемых функций, map создает список кортежей:
>>> map(None,l1,l2,'abcd')
[(1, 10, 'a'), (2, 20, 'b'), (3, 30, 'c'), (None, None, 'd')]
Тогда просто сгладьте список кортежей.
Преимущество, конечно, в том, что map будет работать для любого количества списков и будет работать, даже если они имеют разную длину:
>>> l1=[1,2,3]
>>> l2=[10,20,30]
>>> l3=[101,102,103,104]
>>> [y for x in map(None,l1,l2,l3) for y in x if y in not None]
[1, 10, 101, 2, 20, 102, 3, 30, 103, 104]
Мне нужен был способ сделать это со списками разных размеров, которые не принимал принятый ответ.
В моем решении используется генератор, и его использование выглядит немного приятнее из-за этого:
def interleave(l1, l2):
iter1 = iter(l1)
iter2 = iter(l2)
while True:
try:
if iter1 != None:
yield next(iter1)
except StopIteration:
iter1 = None
try:
if iter2 != None:
yield next(iter2)
except StopIteration:
iter2 = None
if iter1 == None and iter2 == None:
raise StopIteration()
И его использование:
>>> a = [1, 2, 3, 4, 5]
>>> b = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> list(interleave(a, b))
[1, 'a', 2, 'b', 3, 'c', 4, 'd', 5, 'e', 'f', 'g']
>>> list(interleave(b, a))
['a', 1, 'b', 2, 'c', 3, 'd', 4, 'e', 5, 'f', 'g']
Мне больше нравится решение aix. вот еще один способ, я думаю, должен работать в 2.2:
>>> x=range(3)
>>> x
[0, 1, 2]
>>> y=range(7,10)
>>> y
[7, 8, 9]
>>> sum(zip(x,y),[])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "tuple") to list
>>> sum(map(list,zip(x,y)),[])
[0, 7, 1, 8, 2, 9]
и еще один способ:
>>> a=[x,y]
>>> [a[i][j] for j in range(3) for i in (0,1)]
[0, 7, 1, 8, 2, 9]
и
>>> sum((list(i) for i in zip(x,y)),[])
[0, 7, 1, 8, 2, 9]
[el for el in itertools.chain(*itertools.izip_longest([1,2,3], [4,5])) if el is not None]
Пока у вас нет None, который вы хотите сохранить
Чтобы ответить на заголовок вопроса "Чередовать несколько списков одинаковой длины в Python", мы можем обобщить ответ из двух списков @ekhumoro. Это явно требует, чтобы списки были одинаковой длины, в отличие от (элегантного) решения @NPE
import itertools
def interleave(lists):
"""Interleave a list of lists.
:param lists: List of lists; each inner length must be the same length.
:returns: interleaved single list
:rtype: list
"""
if len(set(len(_) for _ in lists)) > 1:
raise ValueError("Lists are not all the same length!")
joint = list(itertools.chain(*lists))
for l_idx, li in enumerate(lists):
joint[l_idx::len(lists)] = li
return joint
Примеры:
>>> interleave([[0,2,4], [1, 3, 5]])
[0, 1, 2, 3, 4, 5]
>>> interleave([[0,2,4], [1, 3, 5], [10, 11, 12]])
[0, 1, 10, 2, 3, 11, 4, 5, 12]
>>> interleave([[0,2,4], [1, 3, 5], [10, 11, 12], [13, 14, 15]])
[0, 1, 10, 13, 2, 3, 11, 14, 4, 5, 12, 15]
>>> interleave([[0,2,4], [1, 3, 5], [10, 11, 12], [13, 14]])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 10, in interleave
ValueError: Lists are not all the same length!
>>> interleave([[0,2,4]])
[0, 2, 4]
Слишком поздно для вечеринки, но я также хотел бы предоставить простое решение, используя метод extend():
list1 = [1, 2, 3]
list2 = [10, 20, 30]
new_list = []
for i in range(len(list1)):
new_list.extend([list1[i], list2[i]])
print(new_list)
Выход:
[1, 10, 2, 20, 3, 30]