Как изменить список в Python?

Ответ 1

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

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

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

Ответ 2

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

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

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

Ответ 3

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

Или

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

Ответ 4

Это дублирует список:

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)

Ответ 5

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

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

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

Ответ 6

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

array.reverse()

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

newArray = array[::-1] 

Ответ 7

Использование slicing, например array = array [:: -1], является опрятным трюком и очень Pythonic, но, возможно, немного неясным для новичков. Использование метода 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]

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

Ответ 8

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

Ответ 9

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

Ответ 10

С reversed и list:

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

Ответ 11

Возможные пути,

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

list1.reverse()

list1[::-1]

Ответ 12

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

Ответ 13

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

>>> 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).

Ответ 14

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

Ответ 15

ОРГАНИЗАЦИОННЫЕ ЗНАЧЕНИЯ:

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

Ответ 16

Использовать список:

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

Ответ 17

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

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

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

Ответ 18

Вы можете использовать reversed()

array=[0,10,20,40]

for e in reversed(array):
  print e

Ответ 19

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

Ответ 20

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

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

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

Ответ 21

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

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

Обмен номерами спереди назад. Использование двух указателей 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]

Ответ 22

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

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

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

Ответ 23

Используйте отмененную функцию, как показано ниже, и распечатайте ее

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

Ответ 24

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

Ответ 25

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

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

Ответ 26

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

print reverse('reversed')

Ответ 27

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 

Ответ 28

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

>>> 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]

Ответ 29

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

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)

Ответ 30

использование

print(reversed(list_name))