如何在Python中反转列表？

如何在Python中执行以下操作？

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

我需要一个数组的元素，但是要从头到尾。

---

#1楼

要反转相同列表，请使用：

array.reverse()

要将反向列表分配给其他列表，请使用：

newArray = array[::-1] 

---

#2楼

严格来说，问题不是如何反向返回列表，而是如何使用示例列表名称array反向列表。

要反转名为"array"的列表，请使用array.reverse() 。

通过使用array = array[::-1]将列表定义为自身的切片修改，还可以使用如上所述的非常有用的slice方法来将列表反转。

---

#3楼

这是复制列表：

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)

---

#4楼

使用清单理解：

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

---

#5楼

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

---

#6楼

如果要将反向列表的元素存储在其他变量中，则可以使用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

---

#7楼

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

---

#8楼

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

---

#9楼

使用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）时间。

---

#10楼

您总是可以像对待堆栈一样对待列表，只是将元素从列表的后端弹出堆栈顶部。 这样，您就可以利用堆栈的先进先出特性。 当然，您正在使用第一个数组。 我确实喜欢这种方法，因为它非常直观，您可以看到一个列表是从后端使用的，而另一个列表是从前端构建的。

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

---

#11楼

使用切片，例如array = array [::-1]是一个巧妙的技巧，非常具有Python风格，但是对于新手来说可能有些晦涩。 使用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]

请注意，这不适用于元组或字符串序列，因为字符串和元组是不可变的，即，您无法写入它们来更改元素。

---

#12楼

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

print reverse('reversed')

---

#13楼

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 

---

#14楼

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

---

#15楼

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

扩展切片语法在2.3.5版的Python 新增功能中很好地解释了

根据注释中的特殊要求， 这是最新的slice文档 。

---

#16楼

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

---

#17楼

您可以通过以下方式使用reversed功能：

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

请注意， reversed(...)不会返回列表。 您可以使用list(reversed(array))获得反向列表。

---

#18楼

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

要么

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

---

#19楼

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

---

#20楼

您的需求到Python中最直接的翻译是for语句：

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

这相当神秘，但可能有用。

---

#21楼

通过切换相反索引的引用就地反转：

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

---

#22楼

我发现（与其他建议相反） l.reverse()是迄今为止在Python 3和2中反转长列表的最快方法。我很想知道其他人是否可以复制这些时间。

l[::-1]可能较慢，因为它在反转列表之前先将其复制。 在由reversed(l)进行的迭代器周围添加list()调用必须增加一些开销。 当然，如果您想要列表的副本或迭代器，则可以使用相应的方法，但是，如果您只想反转列表，则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

---

#23楼

您还可以使用数组索引的按位补码来反向遍历数组：

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

无论您做什么，都不要这样。

---

#24楼

可以使用__reverse__来完成，它返回一个生成器。

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

---

#25楼

我认为在Python中反转列表的最好方法是：

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

该工作已完成，现在您有一个反向列表。

---

#26楼

与reversed和list ：

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

---

#27楼

组织值：

在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价值观的组织很棒。

---

#28楼

使用一些逻辑

使用一些古老的逻辑来练习面试。

从前到后交换数字。 使用两个指针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]

---

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

---

#31楼

此类使用Python魔术方法和迭代器进行反转，并反转列表：

class Reverse(object):
    """ Builds a reverse method using magic methods """

    def __init__(self, data):
        self.data = data
        self.index = len(data)


    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration

        self.index = self.index - 1
        return self.data[self.index]


REV_INSTANCE = Reverse([0, 10, 20, 40])

iter(REV_INSTANCE)

rev_list = []
for i in REV_INSTANCE:
    rev_list.append(i)

print(rev_list)  

输出量

[40, 20, 10, 0]