두 목록을 번갈아 가며 결합하는 Pythonic 방법?

두 개의 목록 이 있는데 첫 번째 목록은 두 번째 목록 보다 정확히 하나 이상의 항목을 포함합니다 . 첫 번째 목록에서 짝수 인덱스 값을 가져오고 두 번째 목록에서 홀수 인덱스 값을 가져 오는 새 목록을 만드는 가장 파이썬적인 방법을 알고 싶습니다.

# 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

어떻게 이것을 달성 할 수 있습니까? 가장 Pythonic 접근 방식은 무엇입니까?

슬라이싱으로 수행하는 한 가지 방법은 다음과 같습니다.

>>> 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보다 큰 경우 :

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]

저는 이것이 가장 비단뱀적인 방법이라고 생각합니다.

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

이렇게하면 목록 A와 B가 각각 3 개의 값 그룹별로 인터레이스됩니다.

['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와 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']

내 테이크 :

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

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