Как я могу перевернуть список в Python?


1037

Как я могу сделать следующее в Python?

array = [0, 10, 20, 40]
for (i = array.length() - 1; i >= 0; i--)

Мне нужно иметь элементы массива, но с конца до начала.

Ответы:


1320

Вы можете использовать reversedфункцию для этого как:

>>> array=[0,10,20,40]
>>> for i in reversed(array):
...     print(i)

Обратите внимание, что reversed(...)не возвращает список. Вы можете получить обратный список, используя list(reversed(array)).


194
Вы не можете просто использовать: массив [:: - 1]?
kdlannoy

134
@kdlannoy Согласно странице, на которую ссылается ответ, «по сравнению с расширенной нарезкой, такой как range (1,4) [:: - 1], reversed () легче читать, работает быстрее и использует существенно меньше памяти. "
Джим Олдфилд

5
Когда я тестировал эту секцию, она была примерно в два раза быстрее (при реверсе списка из 10 тыс. Элементов и создании списка из него). Я не проверял потребление памяти, хотя. reverseможет быть быстрее, хотя, если вам не нужно приводить к списку впоследствии.
Даккарон

5
Стоит отметить, что это не то же самое, что и обратное ([1,2,3]), обратите внимание на 'd' в конце ..., который является одним из других ответов ниже, который делает это на месте, тогда как это возвращает итератор.
Лучано

14
Зачем использовать reversed()вместо нарезки? Прочтите Zen of Python, правило № 7: Читаемость важна!
kramer65

1247
>>> L = [0,10,20,40]
>>> L[::-1]
[40, 20, 10, 0]

Расширенный синтаксис слайса хорошо объясняется в Python. Что нового?2.3.5

По специальному запросу в комментарии это самая последняя документация по срезам .


12
Это работает для любого целого, а не только списки. Недостатком является то, что это не на месте.
швейцарский

6
@Tim возвращает фрагмент, поэтому не меняет фактическое содержимое списка
fortran

12
@lunixbochs в обратном порядке возвращает итератор, а не список в Python 3.
Swiss

2
если естественно не инкапсулировано в массиве
Эйнар Петерсен

2
Я согласен с @Swiss. +1, так как вопрос был в том, что мне нужно иметь элементы массива, но с конца до начала. - reversedвозвращает listreverseiteratorобъект (Python 2.7.x), который затем должен быть повторен - обратная нарезка возвращает обратный список / кортеж / str (в зависимости от того, что вы нарезаете). @Einar Petersen, который переворачивает строку, поэтому вывод правильный. Попробуйте:co2=['ae','ad','ac','ab','aa','z','y','x','w','v','u','t','s','r','q','p','o','n','m','l','k','j','i','h','g','f','e','d','c','b','a'] >>> co2[::-1]
Аарон Ньютон

368
>>> L = [0,10,20,40]
>>> L.reverse()
>>> L
[40, 20, 10, 0]

Или

>>> L[::-1]
[40, 20, 10, 0]

61
[начало: стоп: шаг], поэтому шаг -1
папалаги

37
Подробно: первый изменяет список на месте, второй просто возвращает новый перевернутый список, но он не изменяет исходный.
franzlorenzon

7
второй пример должен состоять в том, L=L[::-1]чтобы фактически перевернуть список, иначе вы только возвращаете значения в обратном порядке
robertmoggach

скажем, если у меня есть l = [1,2,3,4,5,6] и n = 2, их результат должен быть [6,5,1,2,3,4], как мы можем это сделать
Атул Джайн

Вы могли бы сделать это:b = l[-n:] b.reverse() l = b + l[:len(l) - n]
Shoaib Shakeel

56

Это дублировать список:

L = [0,10,20,40]
p = L[::-1]  #  Here p will be having reversed list

Это перевернуть список на месте:

L.reverse() # Here L will be reversed in-place (no new list made)

51

Я думаю, что лучший способ перевернуть список в Python - это сделать:

a = [1,2,3,4]
a = a[::-1]
print(a)
>>> [4,3,2,1]

Работа выполнена, и теперь у вас есть обратный список.


27

Для обращения того же списка используйте:

array.reverse()

Чтобы перевернуть список в другой список, используйте:

newArray = array[::-1] 

27

Использование нарезки, например, array = array [:: - 1], является изящным трюком и очень питонским, но, возможно, немного неясным для новичков. Использование метода reverse () - это хороший способ повседневного кодирования, потому что он легко читается.

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

def reverse_in_place(lst):      # Declare a function
    size = len(lst)             # Get the length of the sequence
    hiindex = size - 1
    its = size/2                # Number of iterations required
    for i in xrange(0, its):    # i is the low index pointer
        temp = lst[hiindex]     # Perform a classic swap
        lst[hiindex] = lst[i]
        lst[i] = temp
        hiindex -= 1            # Decrement the high index pointer
    print "Done!"

# Now test it!!
array = [2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]

print array                    # Print the original sequence
reverse_in_place(array)        # Call the function passing the list
print array                    # Print reversed list


**The result:**
[2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]
Done!
[654, 124, 24, 7, 1, 65, 60, 32, 27, 25, 19, 12, 9, 8, 5, 2]

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


9
Классический обмен может быть сделан через lst[hiindex], lst[i] = lst[i], lst[hiindex], я думаю ... ;-)
Samoth

@Samoth Этот синтаксис не так ясен, и поведение не совсем очевидно. Отдельные шаги имеют больше смысла.
Энтони

почему люди говорят, что такие вещи, как массив [:: - 1], являются питоническими? Дзен-питон учит нас, что явное лучше, чем неявное и считываемое значение. Такие вещи не являются явными и читаемыми вообще.
k4ppa

1
@ k4ppa: array[::-1]отлично читается и явно, если вы знаете Python . «Читаемый» не означает, что «тот, кто никогда раньше не использовал нарезку Python, должен уметь читать его»; [::-1]реверсивный ломтик смехотворно общие идиомы в Python (вы будете сталкиваться его в существующем коде все время), и это прекрасно читается , если вы регулярно использовать Python . Конечно, first10 = [], for i in range(10): first10.append(array[i])ясно и четко, но это не делает его лучше first10 = array[:10].
ShadowRanger

19

Я считаю (вопреки некоторым другим предложениям), что l.reverse()на сегодняшний день это самый быстрый способ перевернуть длинный список в Python 3 и 2. Мне было бы интересно узнать, могут ли другие копировать эти моменты времени.

l[::-1]вероятно, медленнее, потому что он копирует список до его обращения. Добавление list()вызова вокруг итератора reversed(l)должно добавить некоторые накладные расходы. Конечно, если вам нужна копия списка или итератор, используйте эти соответствующие методы, но если вы хотите просто перевернуть список, то, l.reverse()похоже, самый быстрый способ.

функции

def rev_list1(l):
    return l[::-1]

def rev_list2(l):
    return list(reversed(l))

def rev_list3(l):
    l.reverse()
    return l

Список

l = list(range(1000000))

Сроки Python 3.5

timeit(lambda: rev_list1(l), number=1000)
# 6.48
timeit(lambda: rev_list2(l), number=1000)
# 7.13
timeit(lambda: rev_list3(l), number=1000)
# 0.44

Сроки Python 2.7

timeit(lambda: rev_list1(l), number=1000)
# 6.76
timeit(lambda: rev_list2(l), number=1000)
# 9.18
timeit(lambda: rev_list3(l), number=1000)
# 0.46

4
list.reverseсамый быстрый, потому что он разворачивается на месте
warvariuc

Вы правы, list.reverse()это самый быстрый, но вы штрафуете reversed(что лучше всего использовать, когда вы не хотите нового list, просто для итерации существующего listв обратном порядке без изменения оригинала), и среза (который также позволяет избежать мутации оригинала listи, как правило, быстрее, чем reversedкогда ввод небольшой). Да, если вам не нужна копия, все, что копирует, является более дорогим, но в большинстве случаев вы не хотите изменять исходное значение.
ShadowRanger

Похоже, что reversed все равно проигрываетlist.reverse() , но, учитывая, что он не изменяет входные данные list, во многих случаях это лучше. Потеря для reversedмала (~ 1/6 дольше, чем list.reverse()).
ShadowRanger

16
for x in array[::-1]:
    do stuff

Этот метод нарезки не очень читабелен. Pythonic способ будет использовать метод reverse (). ;-)
SimonM

@SimonM reverse () определенно проще понять с первого взгляда.
швейцарский



7

Использование реверсированного (массива) будет, вероятно, лучшим маршрутом.

>>> array = [1,2,3,4]
>>> for item in reversed(array):
>>>     print item

Если вам нужно понять, как можно реализовать это без использования встроенного reversed.

def reverse(a):
    midpoint = len(a)/2
    for item in a[:midpoint]:
        otherside = (len(a) - a.index(item)) - 1
        temp = a[otherside]
        a[otherside] = a[a.index(item)]
        a[a.index(item)] = temp
    return a

Это должно занять O (N) время.


Искал как это сделать без использования обратной функции. Спасибо.
Бернард "Бета Берлин" Пара

Или повернуть вспять на месте, используйте list = list.reverse ()
SimonM

6

Краткое изложение методов с объяснением и результатами синхронизации

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

В целом, лучше использовать встроенные функции / методы для реверса, как и для любой другой функции. В этом случае они примерно в 2-8 раз быстрее в коротких списках (10 элементов) и в ~ 300 + раз быстрее в длинных списках по сравнению с созданными вручную средствами индексации. Это имеет смысл, поскольку у них есть эксперты, которые их создают, изучают и оптимизируют. Они также менее подвержены дефектам и более склонны обрабатывать края и угловые корпуса.

Также подумайте, хотите ли вы:

  1. Отменить существующий список на месте
    • Лучшее решение - object.reverse()метод
  2. Создайте итератор обратного списка (потому что вы собираетесь передать его в цикл for, генератор и т. Д.)
    • Лучшее решение - reversed(object)создание итератора.
  3. или создайте полную копию в обратном порядке
    • Лучшее решение - использовать кусочки с размером шага -1: object[::-1]

Тестовый скрипт

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

from timeit import timeit
from copy import copy

def time_str_ms(t):
    return '{0:8.2f} ms'.format(t * 1000)

Метод 1: Обратное на месте с помощью obj.reverse ()

Если цель состоит в том, чтобы просто изменить порядок элементов в существующем списке, не зацикливая их или не получив копию для работы, используйте <list>.reverse()функцию. Запустите это непосредственно для объекта списка, и порядок всех элементов будет обратным:

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

Мы проверим эффективность этих двух способов - сначала просто перевернуть список на месте (изменить исходный список), а затем скопировать список и затем перевернуть его.

def rev_in_place(mylist):
    mylist.reverse()
    return mylist

def rev_copy_reverse(mylist):
    a = copy(mylist)
    a.reverse()
    return a

Способ 2: перевернуть список с помощью срезов obj[::-1]

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

  • Не влияет на исходный объект
  • Он строит полный список, а не итератор

Общий синтаксис: <object>[first_index:last_index:step]. Для того, чтобы использовать нарезку , чтобы создать простой перевернутый список, использование: <list>[::-1]. Оставляя параметр пустым, он устанавливает для них значения по умолчанию первого и последнего элемента объекта (обратный, если размер шага отрицателен).

Индексирование позволяет использовать отрицательные числа, которые отсчитываются от конца индекса объекта в обратном направлении (т. Е. -2 - второй до последнего элемента). Когда размер шага отрицателен, он начинается с последнего элемента и индексируется в обратном направлении на эту сумму. С этим связана некоторая логика начала и конца, которая была оптимизирована.

def rev_slice(mylist):
    a = mylist[::-1]
    return a

Метод 3: Обратный список с помощью reversed(obj)функции итератора

Есть reversed(indexed_object)функция:

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

Протестируйте как с необработанным итератором, так и создав список из итератора.

def reversed_iterator(mylist):
    a = reversed(mylist)
    return a

def reversed_with_list(mylist):
    a = list(reversed(mylist))
    return a

Способ 4: обратный список с пользовательской / ручной индексацией

Как покажет время, создание собственных методов индексации - плохая идея. Используйте встроенные методы, если вам не нужно делать что-то действительно нестандартное.

Тем не менее, нет меньшего штрафа с меньшими размерами списка, но когда вы увеличиваете масштаб, он становится огромным. Я уверен, что мой код ниже может быть оптимизирован, но я буду придерживаться встроенных методов.

def rev_manual_pos_gen(mylist):
    max_index = len(mylist) - 1
    return [ mylist[max_index - index] for index in range(len(mylist)) ]

def rev_manual_neg_gen(mylist):
    ## index is 0 to 9, but we need -1 to -10
    return [ mylist[-index-1] for index in range(len(mylist)) ]

def rev_manual_index_loop(mylist):
    a = []
    reverse_index = len(mylist) - 1
    for index in range(len(mylist)):
        a.append(mylist[reverse_index - index])
    return a

def rev_manual_loop(mylist):
    a = []
    reverse_index = len(mylist)
    for index, _ in enumerate(mylist):
        reverse_index -= 1
        a.append(mylist[reverse_index])
    return a

Сроки каждого метода

Ниже приведена оставшаяся часть сценария для определения времени каждого метода реверса. Он показывает, что реверсирование на месте obj.reverse()и создание reversed(obj)итератора всегда самые быстрые, а использование слайсов - самый быстрый способ создания копии.

Это также доказывает, что вы не пытаетесь создать способ сделать это самостоятельно, если вам не нужно!

loops_to_test = 100000
number_of_items = 10
list_to_reverse = list(range(number_of_items))
if number_of_items < 15:
    print("a: {}".format(list_to_reverse))
print('Loops: {:,}'.format(loops_to_test))
# List of the functions we want to test with the timer, in print order
fcns = [rev_in_place, reversed_iterator, rev_slice, rev_copy_reverse,
        reversed_with_list, rev_manual_pos_gen, rev_manual_neg_gen,
        rev_manual_index_loop, rev_manual_loop]
max_name_string = max([ len(fcn.__name__) for fcn in fcns ])
for fcn in fcns:
    a = copy(list_to_reverse) # copy to start fresh each loop
    out_str = ' | out = {}'.format(fcn(a)) if number_of_items < 15 else ''
    # Time in ms for the given # of loops on this fcn
    time_str = time_str_ms(timeit(lambda: fcn(a), number=loops_to_test))
    # Get the output string for this function
    fcn_str = '{}(a):'.format(fcn.__name__)
    # Add the correct string length to accommodate the maximum fcn name
    format_str = '{{fx:{}s}} {{time}}{{rev}}'.format(max_name_string + 4)
    print(format_str.format(fx=fcn_str, time=time_str, rev=out_str))

Сроки Результаты

Результаты показывают, что масштабирование лучше всего работает с помощью встроенных методов, которые лучше всего подходят для данной задачи. Другими словами, по мере увеличения количества элементов объекта встроенные методы начинают давать гораздо более высокие результаты производительности.

Вам также лучше использовать лучший встроенный метод, который непосредственно достигает того, что вам нужно, чем связывать вещи вместе. то есть нарезка лучше всего, если вам нужна копия перевернутого списка - это быстрее, чем создание списка из reversed()функции, и быстрее, чем создание копии списка и затем создание на месте obj.reverse(). Но если любой из этих методов действительно вам нужен, он работает быстрее, но не более чем в два раза быстрее. Между тем - пользовательские, ручные методы могут занимать порядки дольше, особенно с очень большими списками.

Для масштабирования со списком из 1000 элементов reversed(<list>)вызов функции занимает ~ 30 мс для настройки итератора, обратное изменение на месте занимает всего ~ 55 мс, использование метода среза занимает ~ 210 мс для создания копии полного обращенного списка, но самый быстрый ручной метод, который я сделал, занял ~ 8400 мс !!

С 2 пунктами в списке:

a: [0, 1]
Loops: 100,000
rev_in_place(a):             24.70 ms | out = [1, 0]
reversed_iterator(a):        30.48 ms | out = <list_reverseiterator object at 0x0000020242580408>
rev_slice(a):                31.65 ms | out = [1, 0]
rev_copy_reverse(a):         63.42 ms | out = [1, 0]
reversed_with_list(a):       48.65 ms | out = [1, 0]
rev_manual_pos_gen(a):       98.94 ms | out = [1, 0]
rev_manual_neg_gen(a):       88.11 ms | out = [1, 0]
rev_manual_index_loop(a):    87.23 ms | out = [1, 0]
rev_manual_loop(a):          79.24 ms | out = [1, 0]

С 10 пунктов в списке:

rev_in_place(a):             23.39 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_iterator(a):        30.23 ms | out = <list_reverseiterator object at 0x00000290A3CB0388>
rev_slice(a):                36.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_copy_reverse(a):         64.67 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_with_list(a):       50.77 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_pos_gen(a):      162.83 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_neg_gen(a):      167.43 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_index_loop(a):   152.04 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_loop(a):         183.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

И с 1000 пунктов в списке:

rev_in_place(a):             56.37 ms
reversed_iterator(a):        30.47 ms
rev_slice(a):               211.42 ms
rev_copy_reverse(a):        295.74 ms
reversed_with_list(a):      418.45 ms
rev_manual_pos_gen(a):     8410.01 ms
rev_manual_neg_gen(a):    11054.84 ms
rev_manual_index_loop(a): 10543.11 ms
rev_manual_loop(a):       15472.66 ms

5

Если вы хотите сохранить элементы обратного списка в какой-либо другой переменной, вы можете использовать revArray = array[::-1]или revArray = list(reversed(array)).

Но первый вариант немного быстрее:

z = range(1000000)
startTimeTic = time.time()
y = z[::-1]
print("Time: %s s" % (time.time() - startTimeTic))

f = range(1000000)
startTimeTic = time.time()
g = list(reversed(f))
print("Time: %s s" % (time.time() - startTimeTic))

Вывод:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

2
В следующий раз вы можете использовать timeit.
Grooveplex

5

ОРГАНИЗАЦИОННЫЕ ЦЕННОСТИ:

В Python порядок списков также можно манипулировать с помощью sort , упорядочивая переменные в числовом / алфавитном порядке:

Временно:

print(sorted(my_list))

Постоянный:

my_list.sort(), print(my_list)

Вы можете сортировать с флагом "reverse = True" :

print(sorted(my_list, reverse=True))

или

my_list.sort(reverse=True), print(my_list)

БЕЗ ОРГАНИЗАЦИИ

Может быть, вы не хотите сортировать значения, а только наоборот. Тогда мы можем сделать это так:

print(list(reversed(my_list)))

** Числа имеют приоритет над алфавитом в порядке листинга. Организация значений Python потрясающая.


4

Используя некоторую логику

Использование логики старой школы для практики на собеседованиях.

Обмен номерами спереди назад. Используя два указателяindex[0] and index[last]

def reverse(array):
    n = array
    first = 0
    last = len(array) - 1
    while first < last:
      holder = n[first]
      n[first] = n[last]
      n[last] = holder
      first += 1
      last -= 1
    return n

input -> [-1 ,1, 2, 3, 4, 5, 6]
output -> [6, 1, 2, 3, 4, 5, -1]

Если мы разделим список на две части и поменяем местами первый с последним индексом, сложность по времени будет более эффективной, чем в приведенном примере.
Израиль Манзо

3

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

>>> array = [0, 10, 20, 40]
>>> [array[~i] for i, _ in enumerate(array)]
[40, 20, 10, 0]

Что бы вы ни делали, не делайте так.


3

Используйте понимание списка:

[array[n] for n in range(len(array)-1, -1, -1)]

3

Другое решение было бы использовать numpy.flip для этого

import numpy as np
array = [0, 10, 20, 40]
list(np.flip(array))
[40, 20, 10, 0]

2

Строго говоря, вопрос не в том, как вернуть список в обратном порядке, а в том, как перевернуть список с примером списка имен array.

Чтобы перевернуть список с именем "array"использовать array.reverse().

Невероятно полезный метод среза, как описано, также может быть использован для реверса списка на месте, определяя список как нарезанную модификацию самого себя, используя array = array[::-1].


3
Последнее предложение неверно, это не отменяет список на месте; это должно сказатьarray[:] = array[::-1]
Антти Хаапала


2

С минимальным количеством встроенных функций, при условии, что это настройки интервью

array = [1, 2, 3, 4, 5, 6,7, 8]
inverse = [] #create container for inverse array
length = len(array)  #to iterate later, returns 8 
counter = length - 1  #because the 8th element is on position 7 (as python starts from 0)

for i in range(length): 
   inverse.append(array[counter])
   counter -= 1
print(inverse)

1

Наиболее прямым переводом вашего требования на Python является следующее for:

for i in xrange(len(array) - 1, -1, -1):
   print i, array[i]

Это довольно загадочно, но может быть полезно.



1

Вы всегда можете рассматривать список как стек, просто выталкивая элементы из верхней части стека из заднего конца списка. Таким образом, вы получаете преимущество первой в последней характеристики стека. Конечно, вы потребляете 1-й массив. Мне нравится этот метод в том смысле, что он довольно интуитивно понятен, поскольку вы видите, что один список используется из серверной части, а другой создается из интерфейсной части.

>>> l = [1,2,3,4,5,6]; nl=[]
>>> while l:
        nl.append(l.pop())  
>>> print nl
[6, 5, 4, 3, 2, 1]

1
list_data = [1,2,3,4,5]
l = len(list_data)
i=l+1
rev_data = []
while l>0:
  j=i-l
  l-=1
  rev_data.append(list_data[-j])
print "After Rev:- %s" %rev_data 


1

Вот способ лениво оценить обратное с помощью генератора :

def reverse(seq):
    for x in range(len(seq), -1, -1): #Iterate through a sequence starting from -1 and increasing by -1.
        yield seq[x] #Yield a value to the generator

Теперь итерируем так:

for x in reverse([1, 2, 3]):
    print(x)

Если вам нужен список:

l = list(reverse([1, 2, 3]))

1

Есть 3 способа получить обратный список:

  1. Метод нарезки 1: reversed_array = array[-1::-1]

  2. Метод нарезки 2: reversed_array2 = array[::-1]

  3. Используя встроенную функцию: reversed_array = array.reverse()

Третья функция фактически перевернула список объектов на месте. Это означает, что копия первичных данных не поддерживается. Это хороший подход, если вы не хотите поддерживать старую версию. Но, похоже, это не решение проблемы, если вы хотите использовать нетронутую и обратную версию.


0
>>> l = [1, 2, 3, 4, 5]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 4, 3, 2, 1]

Это решение примерно в 4,5 тыс. Раз медленнее l[::-1], и в то же время намного менее разборчиво. Функциональное программирование в Python, к сожалению, довольно медленное.
Даккарон
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.