Найкращий спосіб створити "зворотний" список у Python?

У Python, який найкращий спосіб створити новий список, елементи якого збігаються з елементами іншого списку, але в зворотному порядку? (Я не хочу змінювати наявний список на місці.)

Ось одне з рішень, яке мені спало на думку:

new_list = list(reversed(old_list))

Також можна продублювати, old_listа потім повернути дублікат на місце:

new_list = list(old_list) # or `new_list = old_list[:]`
new_list.reverse()

Чи є кращий варіант, який я пропустив? Якщо ні, чи є вагома причина (наприклад, ефективність) використовувати один із наведених підходів над іншим?

newlist = oldlist[::-1]

[::-1]Нарізка (що моя дружина Анна любить називати «марсіанську смайлик» ;-) означає: зріз всієї послідовності, з кроком -1, тобто в зворотному. Це працює для всіх послідовностей.

Зверніть увагу, що це ( та альтернативи, про які ви згадали) еквівалентно "неглибокій копії", тобто: якщо елементи можна змінювати, і ви викликаєте на них мутаторів, мутації елементів, що містяться в оригінальному списку, також містяться в елементах у перевернутий список, і навпаки. Якщо вам потрібно цього уникнути, єдиним хорошим варіантом є a copy.deepcopy(хоча це завжди потенційно дорога операція), за яким у цьому випадку йде a .reverse.

А тепер давайте timeit. Підказка: Алекс [::-1]найшвидший :)

$ p -m timeit "ol = [1, 2, 3]; nl = list(reversed(ol))"
100000 loops, best of 3: 2.34 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = list(ol); nl.reverse();"
1000000 loops, best of 3: 0.686 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = ol[::-1];"
1000000 loops, best of 3: 0.569 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = [i for i in reversed(ol)];"
1000000 loops, best of 3: 1.48 usec per loop


$ p -m timeit "ol = [1, 2, 3]*1000; nl = list(reversed(ol))"
10000 loops, best of 3: 44.7 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = list(ol); nl.reverse();"
10000 loops, best of 3: 27.2 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = ol[::-1];"
10000 loops, best of 3: 24.3 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = [i for i in reversed(ol)];"
10000 loops, best of 3: 155 usec per loop

Оновлення: Доданий метод comp comp, запропонований inspectorG4dget. Я нехай результати говорять самі за себе.

Коригування

Варто надати базовий орієнтир / коригування для обчислення часу за sdolan, який показує ефективність "зворотного" без часто непотрібного list()перетворення. Ця list()операція додає додаткові 26 usecs до середовища виконання і потрібна лише в тому випадку, якщо ітератор неприйнятний.

Результати:

reversed(lst) -- 11.2 usecs

list(reversed(lst)) -- 37.1 usecs

lst[::-1] -- 23.6 usecs

Розрахунки:

# I ran this set of 100000 and came up with 11.2, twice:
python -m timeit "ol = [1, 2, 3]*1000; nl = reversed(ol)"
100000 loops, best of 3: 11.2 usec per loop

# This shows the overhead of list()
python -m timeit "ol = [1, 2, 3]*1000; nl = list(reversed(ol))"
10000 loops, best of 3: 37.1 usec per loop

# This is the result for reverse via -1 step slices
python -m timeit "ol = [1, 2, 3]*1000;nl = ol[::-1]"
10000 loops, best of 3: 23.6 usec per loop

Висновки:

Висновок цих тестів reversed()швидший, ніж фрагмент, [::-1]на 12,4 usecs