Лучший способ чередовать два или более списков в Python?

Question

Предположим, у меня есть список:

l=['a','b','c']

И его список суффиксов:

l2 = ['a_1', 'b_1', 'c_1']

Я бы хотел, чтобы желаемый результат был:

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

Результатом является чередованная версия двух списков выше.

Я могу написать обычный цикл for, чтобы сделать это, но мне интересно, есть ли более Pythonic способ (например, с использованием понимания списка илилямбда), чтобы сделать это.

Я пробовал что-то вроде этого:

list(map(lambda x: x[1]+'_'+str(x[0]+1), enumerate(a)))
# this only returns ['a_1', 'b_2', 'c_3']

Кроме того, какие изменения нужно будет сделать для общего случая, т. е. для 2 или более списковгде l2 не обязательно является производной от l?

Answer 1

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

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

Answer 2

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

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, заключается в том, что на момент написания, понимание списка не поддерживает распаковку кортежей.

Answer 3

Вот моя простая реализация

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

Answer 4

Если вы хотите вернуть [["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)),[])

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

Answer 5

Вы можете использовать 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']

Answer 6

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

---

Sliced ​​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.Создайте пары, используя zip, а затем сгладьте их, используя 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
    ]

Answer 7

Вы можете использовать понимание списка следующим образом:

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