2017-01-20 7 views
2

Пусть у меня есть списокСписок постижение с элементами появляются дважды

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

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

['a', 'a', 'c', 'c', 'b', 'b'] 

и я хочу сделайте это самым питоническим способом.

Моя половина решение делает что-то вроде

[[l[i], l[i]] for i in range(len(l))] 

, который дает

[['a', 'a'], ['c', 'c'], ['b', 'b']] 

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

У кого-нибудь есть идея сделать это за один раз? Очевидно, что такие вещи, как l * 2, не помогли бы, так как это дало ['a', 'c', 'b', 'a', 'c', 'b'], и я хочу, чтобы те же самые элементы смежны.

ответ

4
l_2 = [item for item in l for i in range(n)] 

Ссылка на происхождение: Stackoverflow: Repeating elements of a list n times

+0

Выбора этой, как это кажется более элегантным. Обратите внимание, что время выполнения этого задания дает 1000000 циклов, лучше всего 3: 1.49 мкс на петлю' по сравнению с ответом @Yousaf, который дает «Самый медленный прогон занимает 5,32 раза дольше, чем самый быстрый. Это может означать, что промежуточный результат кэшируется. 1000000 циклов, наилучший из 3: 1.12 мкс за цикл' –

+1

Я считаю, что использовать более длинный список для синхронизации. Три элемента настолько коротки, что время не имеет большого значения. Я также получил «Самый медленный прогон в 5,41 раза дольше, чем самый быстрый» для кода выше. – UpSampler

4

Использование только list comprehension, вы можете сделать:

[i for j in my_list for i in [j]*2] 

Выход:

>>> my_list = ['a', 'c', 'b'] 
>>> [i for j in my_list for i in [j]*2] 
['a', 'a', 'c', 'c', 'b', 'b'] 
3

Вы можете zip список против самого себя, а затем расплющить его в списке понимание.

>>> [i for j in zip(l,l) for i in j] 
['a', 'a', 'c', 'c', 'b', 'b'] 
2

Вы можете использовать zip функция

l = ['a', 'c', 'b'] 
a = [i for j in zip(l,l) for i in j] 
print(a) 

Выход

['a', 'a', 'c', 'c', 'b', 'b'] 
1

Более общая:

def ntimes(iterable, times=2): 
    for elt in iterable: 
     for _ in range(times): 
      yield elt 
1

Вот краткое решение без списка понимания, используя интуитивное представление l*2:

sorted(l*2, key=l.index) 
#['a', 'a', 'c', 'c', 'b', 'b'] 
1

Если вы любите функциональные подходы, вы можете сделать это:

from itertools import chain, tee 

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

list(chain.from_iterable(zip(*tee(l, n)))) 

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

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

 Смежные вопросы

  • Нет связанных вопросов^_^