Своп все элементы в списке в Python 3.4

Question

Допустим, мой список выглядит следующим образом:

myList = ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight'] 

И я хочу, чтобы результат выглядел так:

One, Eight, Two, Seven, Three, Six, Four, Five 

Что было бы самым простым способом идти об этом?

Answer 1

from collections import deque 

myList = ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight'] 


def swap(items): 
    items = deque(items) 
    while items: 
     yield items.popleft() 
     try: 
      yield items.pop() 
     except IndexError: 
      pass 

print list(swap(myList)) 

Edit: Теперь неразрушающих и справляется с неровными списками длины

Edit: с помощью Deque поэтому его память эффективной

Answer 2

Если я хорошо понимаю, это создаст новый список с требуемым заказом.

myList = ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight'] 
i = 0 
new_list = [] 
while i < len(myList)/2: 
    new_list.append(myList[i]) 
    i += 1 
    new_list.append(myList[-i]) 
print ', '.join(new_list) 

Answer 3

Кусочек:

>>> result = list(myList) 
>>> result[::2] = myList[:4] 
>>> result[::-2] = myList[4:] 
>>> result 
['One', 'Eight', 'Two', 'Seven', 'Three', 'Six', 'Four', 'Five'] 

Первое задание может заменить на все, что создает список правильной длины, тогда первые 4 элемента myList становятся каждым secon d элемент результата, а последние 4 элемента - каждый второй элемент, идущий назад от конца.

и, конечно же, если вы хотите, чтобы вывод без скобок:

>>> print(', '.join(result)) 
One, Eight, Two, Seven, Three, Six, Four, Five 

Если вы не возражаете splatting первоначальный список вы можете сделать все это в одной строке:

>>> myList[::2], myList[::-2] = myList[:4], myList[4:] 
>>> myList 
['One', 'Eight', 'Two', 'Seven', 'Three', 'Six', 'Four', 'Five'] 

Answer 4

myList = ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight'] 

z=[x for x in myList if myList.index(x)>=len(myList)/2] 
print zip(myList,reversed(z)) 

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

Answer 5

Если вы хотите один вкладыша, вы можете посмотреть по адресу:

final = [el for zipped in zip(lst[:4], reversed(lst[4:])) for el in zipped] 

Answer 6

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

def interleave(l): 
    """ 
    Non-destructive front-and-back iterleave of list items. 
    """ 
    midpoint, odd_length = divmod(len(l), 2) 
    for i in range(midpoint): 
     yield l[i] 
     yield l[-i-1] 
    if odd_length: 
     yield l[midpoint] 

Или:

def interleave2(l): 
    """ 
    Non-destructive front-and-back iterleave of list items. 
    Uses zip and reversed generators and list slicing. 
    Arguably more "Pythonic," but depends on more in-flight 
    infrastructure and consumes more memory. 
    """ 
    midpoint, odd_length = divmod(len(l), 2) 
    for front, back in zip(l[:midpoint], reversed(l[midpoint:])): 
     yield front 
     yield back 
    if odd_length: 
     yield l[midpoint] 

А вот немного импровизированный тест Жгут для подтверждения результаты правильны:

myList = ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight'] 
myListAnswer = ['One', 'Eight', 'Two', 'Seven', 'Three', 'Six', 'Four', 'Five'] 

answers = {} 
for algorithm in [interleave, interleave2]: 
    print() 
    print(algorithm.__name__, "\n", "=" * len(algorithm.__name__), "\n") 

    # test the simple case 
    assert list(algorithm(myList)) == myListAnswer 

    # test a number of list sizes 
    for j in range(11): 
     # run algorithm and show inputs and outputs 
     l = list(range(j)) 
     print("size:", j) 
     print("list:", l) 
     answer = list(algorithm(l)) 
     print("answer:", answer) 

     # check assertions 
     prev_answer = answers.setdefault(j, answer) 
     assert len(l) == len(answer) 
     assert l == sorted(answer) 
     assert answer == prev_answer 
     print("--") 

это дает:

interleave 
========== 

size: 0 
list: [] 
answer: [] 
-- 
size: 1 
list: [0] 
answer: [0] 
-- 
size: 2 
list: [0, 1] 
answer: [0, 1] 
-- 
size: 3 
list: [0, 1, 2] 
answer: [0, 2, 1] 
-- 
size: 4 
list: [0, 1, 2, 3] 
answer: [0, 3, 1, 2] 
-- 
size: 5 
list: [0, 1, 2, 3, 4] 
answer: [0, 4, 1, 3, 2] 
-- 
size: 6 
list: [0, 1, 2, 3, 4, 5] 
answer: [0, 5, 1, 4, 2, 3] 
-- 
size: 7 
list: [0, 1, 2, 3, 4, 5, 6] 
answer: [0, 6, 1, 5, 2, 4, 3] 
-- 
size: 8 
list: [0, 1, 2, 3, 4, 5, 6, 7] 
answer: [0, 7, 1, 6, 2, 5, 3, 4] 
-- 
size: 9 
list: [0, 1, 2, 3, 4, 5, 6, 7, 8] 
answer: [0, 8, 1, 7, 2, 6, 3, 5, 4] 
-- 
size: 10 
list: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
answer: [0, 9, 1, 8, 2, 7, 3, 6, 4, 5] 
-- 

# ...and continues on with similar output for interleave2 ...