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

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

расширенный синтаксис среза хорошо объясняется в Python какая новая запись для выпуска 2.3.5

по специальному запросу в комментарий это самый последний фрагмент документации.

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

или

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

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

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)

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

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

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

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

array.reverse()

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

newArray = array[::-1] 

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

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

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]

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

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

Я нахожу (вопреки некоторым другим предложениям), что 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

С reversed и list:

>>> list1 = [1,2,3]
>>> reversed_list = list(reversed(list1))
>>> reversed_list
>>> [3, 2, 1]

возможными способами,

list1 = [3,4,3,545,6,4,34,243]

list1.reverse()

list1[::-1]

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

использование reversed (array) было бы, вероятно, лучшим маршрутом.

>>> 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) времени.

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

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

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

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

можно использовать reversed()

array=[0,10,20,40]

for e in reversed(array):
  print e

def reverse(text):
    output = []
    for i in range(len(text)-1, -1, -1):
        output.append(text[i])
    return output

использовать список понимание:

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

самый прямой перевод вашего требования на Python-это for о себе:

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

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

использовать отменено как следовать и распечатать его

>>> for element in reversed(your_array):
...     print element

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

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

def reverse(text):
    lst=[]
    for i in range(0,len(text)):
        lst.append(text[(len(text)-1)-i])
    return ''.join(lst)

print reverse('reversed')

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 

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

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

что бы вы ни делали, не делайте это таким образом.

def reverse(my_list):
  L = len(my_list)
  for i in range(L/2):
    my_list[i], my_list[L-i - 1] = my_list[L-i-1], my_list[i]
  return my_list

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

ОРГАНИЗУЮЩИЕ ЗНАЧЕНИЯ:

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

временно:

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 является удивительной.

>>> L = [1, 2, 3, 4]
>>> L = [L[-i] for i in range(1, len(L) + 1)]
>>> L
[4, 3, 2, 1]

реверсирование на месте путем переключения ссылок противоположных индексов:

>>> l = [1,2,3,4,5,6,7]    
>>> for i in range(len(l)//2):
...     l[i], l[-1-i] = l[-1-i], l[i]
...
>>> l
[7, 6, 5, 4, 3, 2, 1]

можно сделать с помощью __reverse__ , который возвращает генератор.

>>> l = [1,2,3,4,5]
>>> for i in l.__reversed__():
...   print i
... 
5
4
3
2
1
>>>