Pythonic cách kết hợp hai danh sách trong một kiểu xen kẽ?

Tôi có hai danh sách, danh sách đầu tiên được đảm bảo chứa chính xác một mục nhiều hơn danh sách thứ hai . Tôi muốn biết cách Pythonic nhất để tạo một danh sách mới có giá trị chỉ số chẵn đến từ danh sách đầu tiên và có giá trị chỉ mục lẻ đến từ danh sách thứ hai.

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

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

Điều này hoạt động, nhưng không đẹp:

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

Làm thế nào khác có thể đạt được điều này? Cách tiếp cận Pythonic nhất là gì?

Đây là một cách để làm điều đó bằng cách cắt:

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

Có một công thức cho điều này trong itertoolstài liệu :

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

BIÊN TẬP:

Đối với phiên bản của python lớn hơn 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))

Điều này sẽ làm những gì bạn muốn:

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

Tôi nghĩ đây là cách làm đáng sợ nhất.

Không có itertools và giả sử l1 dài hơn l2 1 mục:

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

Sử dụng itertools và giả sử rằng danh sách không chứa None:

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

Tôi biết các câu hỏi hỏi về hai danh sách với một danh sách có một mục nhiều hơn danh sách kia, nhưng tôi đã nghĩ rằng tôi sẽ đặt điều này cho những người khác có thể tìm thấy câu hỏi này.

Đây là giải pháp của Duncan được điều chỉnh để hoạt động với hai danh sách có kích thước khác nhau.

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

Kết quả này cho ra:

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

Nếu cả hai danh sách có độ dài bằng nhau, bạn có thể thực hiện:

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

Vì danh sách đầu tiên có một phần tử nữa, bạn có thể thêm phần tử đó vào sau:

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

Đây là một lớp lót thực hiện điều đó:

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

Điều này dựa trên đóng góp của Carlos Valiente ở trên với một tùy chọn để thay thế các nhóm gồm nhiều mục và đảm bảo rằng tất cả các mục đều có trong đầu ra:

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

Thao tác này sẽ xen kẽ danh sách A và B theo từng nhóm 3 giá trị:

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

Có thể hơi muộn để mua thêm một miếng lót trăn khác. Điều này hoạt động khi hai danh sách có kích thước bằng nhau hoặc không bằng nhau. Một điều không có giá trị gì là nó sẽ sửa đổi a và b. Nếu đó là sự cố, bạn cần sử dụng các giải pháp khác.

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

Lấy của tôi:

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

Đây là một lớp lót sử dụng tính năng hiểu danh sách, cùng với các thư viện khác:

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

Đây là một cách tiếp cận khác, nếu bạn cho phép thay đổi danh sách ban đầu của mình bằng tác dụng phụ:

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

Dừng trên chặng ngắn nhất:

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

Chắc chắn, việc giải quyết phương thức / __ next__ tiếp theo có thể nhanh hơn.

Điều này thật khó chịu nhưng hoạt động bất kể kích thước của danh sách:

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

Nhiều lớp lót một lớp lấy cảm hứng từ các câu trả lời cho một câu hỏi khác :

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]

Làm thế nào về numpy? Nó cũng hoạt động với các chuỗi:

import numpy as np

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

Kết quả:

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

Một giải pháp thay thế theo cách chức năng & bất biến (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),[])

Tôi sẽ làm đơn giản:

chain.from_iterable( izip( list1, list2 ) )

Nó sẽ đi kèm với một trình lặp mà không cần tạo thêm bất kỳ nhu cầu lưu trữ nào.

Tôi quá già để hiểu danh sách, vì vậy:

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