Лучший способ чередования двух или более списков в python?

Ответ 1

yield

Вы можете использовать генератор для элегантного решения. На каждой итерации выдаете дважды - один раз с исходным элементом и один раз с элементом с добавленным суффиксом.

Генератор должен быть исчерпан; это можно сделать, прикрепив вызов list в конце.

def transform(l):
    for i, x in enumerate(l, 1):
        yield x
        yield f'{x}_{i}'  # {}_{}'.format(x, i)

Вы также можете переписать это, используя синтаксис yield from для делегирования генератора:

def transform(l):
    for i, x in enumerate(l, 1):
        yield from (x, f'{x}_{i}') # (x, {}_{}'.format(x, i))

out_l = list(transform(l))
print(out_l)
['a', 'a_1', 'b', 'b_2', 'c', 'c_3']

Если вы используете версию, более раннюю, чем python-3.6, замените f'{x}_{i}' '{}_{}'.format(x, i).

Обобщая
Рассмотрим общий сценарий, где у вас есть N списков в форме:

l1 = [v11, v12, ...]
l2 = [v21, v22, ...]
l3 = [v31, v32, ...]
...

Который вы хотели бы чередовать. Эти списки не обязательно являются производными друг от друга.

Для обработки операций чередования с этими N списками вам нужно будет выполнить итерации по парам:

def transformN(*args):
    for vals in zip(*args):
        yield from vals

out_l = transformN(l1, l2, l3, ...)

list.__setitem__

Я бы порекомендовал это с точки зрения производительности. Сначала выделите место для пустого списка, а затем назначьте элементы списка на их соответствующие позиции, используя назначение разделенного списка. l переходит в четные индексы, а l' (l модифицированный) переходит в нечетные индексы.

out_l = [None] * (len(l) * 2)
out_l[::2] = l
out_l[1::2] = [f'{x}_{i}' for i, x in enumerate(l, 1)]  # [{}_{}'.format(x, i) ...]

print(out_l)
['a', 'a_1', 'b', 'b_2', 'c', 'c_3']

Это неизменно самый быстрый из моих таймингов (ниже).

Обобщая
Чтобы обрабатывать N списков, итеративно присваивайте срезы.

list_of_lists = [l1, l2, ...]

out_l = [None] * len(list_of_lists[0]) * len(list_of_lists)
for i, l in enumerate(list_of_lists):
    out_l[i::2] = l

zip + chain.from_iterable

Функциональный подход, аналогичный решению @chrisz. itertools.chain пары, используя zip а затем itertools.chain их, используя itertools.chain.

from itertools import chain
# [{}_{}'.format(x, i) ...]
out_l = list(chain.from_iterable(zip(l, [f'{x}_{i}' for i, x in enumerate(l, 1)]))) 

print(out_l)
['a', 'a_1', 'b', 'b_2', 'c', 'c_3']

iterools.chain широко считается подходом к уплощению списка.

Обобщая
Это самое простое решение для обобщения, и я подозреваю, что наиболее эффективно для нескольких списков, когда N велико.

list_of_lists = [l1, l2, ...]
out_l = list(chain.from_iterable(zip(*list_of_lists)))

Спектакль

Давайте взглянем на некоторые perf-тесты для простого случая двух списков (один список с суффиксом). Общие случаи не будут проверяться, так как результаты широко варьируются в зависимости от данных.

Код для сравнения, для справки.

функции

def cs1(l):
    def _cs1(l):
        for i, x in enumerate(l, 1):
            yield x
            yield f'{x}_{i}'

    return list(_cs1(l))

def cs2(l):
    out_l = [None] * (len(l) * 2)
    out_l[::2] = l
    out_l[1::2] = [f'{x}_{i}' for i, x in enumerate(l, 1)]

    return out_l

def cs3(l):
    return list(chain.from_iterable(
        zip(l, [f'{x}_{i}' for i, x in enumerate(l, 1)])))

def ajax(l):
    return [
        i for b in [[a, '{}_{}'.format(a, i)] 
        for i, a in enumerate(l, start=1)] 
        for i in b
    ]

def ajax_cs0(l):
    # suggested improvement to ajax solution
    return [j for i, a in enumerate(l, 1) for j in [a, '{}_{}'.format(a, i)]]

def chrisz(l):
    return [
        val 
        for pair in zip(l, [f'{k}_{j+1}' for j, k in enumerate(l)]) 
        for val in pair
    ]

Ответ 2

Вы можете использовать понимание списка так:

l=['a','b','c']
new_l = [i for b in [[a, '{}_{}'.format(a, i)] for i, a in enumerate(l, start=1)] for i in b]

Выход:

['a', 'a_1', 'b', 'b_2', 'c', 'c_3']

Необязательный, более короткий метод:

[j for i, a in enumerate(l, 1) for j in [a, '{}_{}'.format(a, i)]]

Ответ 3

Вы можете использовать zip:

[val for pair in zip(l, [f'{k}_{j+1}' for j, k in enumerate(l)]) for val in pair]

Выход:

['a', 'a_1', 'b', 'b_2', 'c', 'c_3']

Ответ 4

Здесь моя простая реализация

l=['a','b','c']
# generate new list with the indices of the original list
new_list=l + ['{0}_{1}'.format(i, (l.index(i) + 1)) for i in l]
# sort the new list in ascending order
new_list.sort()
print new_list
# Should display ['a', 'a_1', 'b', 'b_2', 'c', 'c_3']

Ответ 5

(Edited)

Использование списка:

[ l[int(i/2)]+"_"+str(int(i/2)+1) if i%2!=0 else l[int(i/2)] for i in range(0,2*len(l))]

# l=['b', 'a', 'd', 'c']
# output : ['b', 'b_1', 'a', 'a_2', 'd', 'd_3', 'c', 'c_4']

Ответ 6

Если вы хотите вернуть [["a","a_1"],["b","b_2"],["c","c_3"]] вы можете написать

new_l=[[x,"{}_{}".format(x,i+1)] for i,x in enumerate(l)]

Это не то, что вы хотите, вместо этого вы хотите ["a","a_1"]+["b","b_2"]+["c","c_3"]. Это можно сделать из результата операции выше, используя sum(); поскольку вы суммируете списки, вам нужно добавить пустой список в качестве аргумента, чтобы избежать ошибки. Так что это дает

new_l=sum(([x,"{}_{}".format(x,i+1)] for i,x in enumerate(l)),[])

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

Ответ 7

Очень простое решение:

out_l=[]
for i,x in enumerate(l,1):
    out_l.extend([x,f"{x}_{i}"])

Ответ 8

Вот более простое понимание списка для этой проблемы:

l = ['a', 'b', 'c']
print([ele for index, val in enumerate(l) for ele in (val, val + f'_{index + 1}')])

Выход:

['a', 'a_1', 'b', 'b_2', 'c', 'c_3']

Обратите внимание, что это просто более простое решение для чередования двух списков. Это не решение для нескольких списков. Причина, по которой я использую два for циклов, заключается в том, что на момент написания, понимание списка не поддерживает распаковку кортежей.