Как чередовать два списка по кускам

Question

Я хочу объединить два списка, но определенным образом c. Я хочу, чтобы каждые 4 значения меняли список, из которого я беру значения.

Вот пример, но набор данных, над которым я работаю, гораздо больше:

List1 = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8]
List2 = [2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8]

#Expected merged list
[1.1, 1.2, 1.3, 1.4, 2.1, 2.2, 2.3, 2.4, 1.5, 1.6, 1.7, 1.8, 2.5, 2.6, 2.7, 2.8]

Здесь я беру первые 4 из List1, затем беру следующие 4 из List2, а затем go обратно на List1 et c.

Это похоже на Вопрос о переплетении двух списков , но вместо:

c = [a[0], b[0], a[1], b[1], ..., a[n], b[n]]

Я хочу

c = [a[0], a[1], a[2], a[3], b[0], b[1], b[2], b[3], ..., a[n-3], a[n-2], a[n-1], a[n], b[n-3], b[n-2], b[n-1], b[n]]

Answer 1

Вы можете попробовать это. Вы можете использовать extend.

>>> l=[]
>>> for i in range(0,len(List1),4):
        l.extend(List1[i:i+4])
        l.extend(List2[i:i+4])
>>> l
[1.1, 1.1, 1.1, 1.1, 2.1, 2.1, 2.1, 2.1, 1.2, 1.2, 1.2, 1.2, 2.2, 2.2, 2.2, 2.2]
>>> 

Answer 2

В случае, если вы хотите иметь возможность обрабатывать любой длины списка (не только делится на 4, а не только когда два списка имеют одинаковый размер) и любое количество списков ...

Любые длины списков

Это может обрабатывать любые длины списков, включая случаи, когда два списка имеют совершенно разные длины:

result = []
it1, it2 = iter(List1), iter(List2)
while chunk := list(islice(it1, 4)) + list(islice(it2, 4)):
    result += chunk

Небольшая альтернатива:

result = []
it1, it2 = iter(List1), iter(List2)
while chunk := list(chain(islice(it1, 4), islice(it2, 4))):
    result += chunk

Демонстрация:

>>> from itertools import islice
>>> List1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> List2 = ['a', 'b', 'c', 'd', 'e']
>>> k = 4

>>> result = []
>>> it1, it2 = iter(List1), iter(List2)
>>> while chunk := list(islice(it1, k)) + list(islice(it2, k)):
        result += chunk

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

Любое количество списков (любой длины)

result = []
iters = deque(map(iter, Lists))
while iters:
    it = iters.popleft()
    if chunk := list(islice(it, 4)):
        result += chunk
        iters.append(it)

Демонстрация (выходные данные отформатированы для наглядности):

>>> from itertools import islice
>>> from collections import deque
>>> Lists = [
    [1.1, 1.1, 1.1, 1.1, 1.2, 1.2, 1.2, 1.2],
    [2.1, 2.1, 2.1, 2.1, 2.2, 2.2, 2.2, 2.2, 2.3],
    [3.1, 3.1, 3.1, 3.1, 3.2, 3.2, 3.2, 3.2, 3.3, 3.4]
]
>>> k = 4

>>> result = []
>>> iters = deque(map(iter, Lists))
>>> while iters:
        it = iters.popleft()
        if chunk := list(islice(it, 4)):
            result += chunk
            iters.append(it)

>>> result
[1.1, 1.1, 1.1, 1.1, 2.1, 2.1, 2.1, 2.1, 3.1, 3.1, 3.1, 3.1,
 1.2, 1.2, 1.2, 1.2, 2.2, 2.2, 2.2, 2.2, 3.2, 3.2, 3.2, 3.2,
 2.3, 3.3, 3.4]

Answer 3

Что по этому поводу:

A = [1.1, 1.1, 1.1, 1.1, 1.2, 1.2, 1.2, 1.2, 1.3, 1.3]
B = [2.1, 2.1, 2.1, 2.1, 2.2, 2.2, 2.2, 2.2, 2.3, 2.3]


sep = 4
num = len(A)
iterations = int(num / sep) + 1

merged = []
for i in range(iterations):
    start = sep * i
    end = sep * (i + 1)
    merged.extend(A[start:end])
    merged.extend(B[start:end])

print(merged)

>>> '[1.1, 1.1, 1.1, 1.1, 2.1, 2.1, 2.1, 2.1, 1.2, 1.2, 1.2, 1.2, 2.2, 2.2, 2.2, 2.2, 1.3, 1.3, 2.3, 2.3]'

Answer 4

Как и мой другой ответ, он может обрабатывать любые длины списков, но также может обрабатывать любое количество списков:

def gen(i, lst):
    for j, x in enumerate(lst):
        yield j // 4, i, x

result = [x[2] for x in merge(*(gen(*e) for e in enumerate(Lists)))]

Демо:

>>> from heapq import merge
>>> Lists = [
    [1.1, 1.1, 1.1, 1.1, 1.2, 1.2, 1.2, 1.2],
    [2.1, 2.1, 2.1, 2.1, 2.2, 2.2, 2.2, 2.2],
    [3.1, 3.1, 3.1, 3.1, 3.2, 3.2, 3.2, 3.2]
]
>>> def gen(i, lst):
        for j, x in enumerate(lst):
            yield j // 4, i, x

>>> [x[2] for x in merge(*(gen(*e) for e in enumerate(Lists)))]
[1.1, 1.1, 1.1, 1.1, 2.1, 2.1, 2.1, 2.1, 3.1, 3.1, 3.1, 3.1,
 1.2, 1.2, 1.2, 1.2, 2.2, 2.2, 2.2, 2.2, 3.2, 3.2, 3.2, 3.2]

Answer 5

Вы можете просто попробовать это:

l = [List1 [0]] * 4+ [List2 [1]] * 4+ [List1 [-1]] * 4+ [List2 [-1 ]] * 4

Answer 6

Этот код должен работать примерно так же:

    lst1 = [1.1, 1.1, 1.1, 1.1, 1.2, 1.2, 1.2, 1.2]
    lst2 = [2.1, 2.1, 2.1, 2.1, 2.2, 2.2, 2.2, 2.2]

    def combine(lst1 = [], lst2 = []):
        result = []
        for i in range(0,len(lst1), 4):
            for j in range(i, i + 4):
                result.append(lst1[i]) 
            result.append(lst2.pop(0))
            result.append(lst2.pop(0))
        for item in lst2:
            result.append(item)
        return result

    print(combine(lst1, lst2)) # [1.1, 1.1, 1.1, 1.1, 2.1, 2.1, 1.2, 1.2, 1.2, 1.2, 2.1, 2.1, 2.2, 2.2, 2.2, 2.2]

Мы четыре раза перебираем первый список, затем добавляем все элементы в наш результат и удаляем первые 2 элемента head в lst2 в наш результат, затем, наконец, все, что осталось в lst2, также загружается в наш результат.