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

这里将解释扩展片语法。请参见文档。

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

要获得一个新的反向列表，应用reversed函数并将项目收集到一个列表中:

>>> xs = [0, 10, 20, 40]
>>> list(reversed(xs))
[40, 20, 10, 0]

在列表中向后迭代:

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

使用列表。Reverse将列表就地反转:

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

使用切片以相反的顺序创建一个新列表:

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

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

将你的需求转换成Python的最直接的方法是这样的for语句:

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

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

要反转相同的列表，请使用:

array.reverse()

将反向列表赋值到其他列表使用:

newArray = array[::-1] 

问题不是如何反向返回一个列表，而是如何使用示例列表名数组反向返回一个列表。

反转名为“array”的列表使用array.reverse()。

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

使用列表推导式:

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

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

如果你想在其他变量中存储反转列表的元素，那么你可以使用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

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

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

使用反向(数组)可能是最好的方法。

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

如果你需要了解如何实现这个不使用内置反转。

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)时间。

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

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

使用切片，例如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]

注意，这将不适用于元组或字符串序列，因为字符串和元组是不可变的，也就是说，您不能写入它们来更改元素。

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 

>>> l = [1, 2, 3, 4, 5]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 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]

我发现(与其他一些建议相反)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

List

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

你也可以使用数组索引的逐位补码反向遍历数组:

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

不管你做什么，不要这样做;)

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

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

带颠倒和列表的:

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

使用一些逻辑

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

从前到后交换数字。使用两个指针索引[0]和索引[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, 5, 4, 3, 2, 1, -1]

内置功能最少，假设是面试设置

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)

use

print(list(reversed(list_name)))

一行代码中用户输入值的反向:

for i in input()[::-1]: print(i,end='')

这个类使用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]

下面是一种使用生成器对反向进行惰性计算的方法:

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

另一个解决方案是使用numpy。翻一下

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

有3种方法可以获得反向列表:

切片方法1:reversed_array = array[-1::-1] 切片方法二: Reversed_array2 = array[::-1] 使用内置函数:reversed_array = array.reverse()

第三个函数实际上颠倒了列表对象。这意味着不维护原始数据的副本。如果您不想维护旧版本，这是一个很好的方法。但如果你想要原始和反转的版本，这似乎不是一个解决方案。

逆向方法综述

有三种不同的内置方法来反转列表。哪种方法最好取决于你是否需要:

就地反转现有列表(更改原始列表变量) 最好的解决方案是object.reverse()方法 创建反转列表的迭代器(因为要将其提供给for循环、生成器等)。 最好的解决方案是reversed(object)，它创建了迭代器 创建列表的副本，只是顺序相反(以保留原始列表) 最佳解决方案是使用步长为-1的切片:object[::-1]

从速度的角度来看，最好使用上面的内置函数来反转列表。对于反转，与手动创建的循环或生成器相比，它们在短列表(10项)上的速度快2到8倍，在长列表上的速度快300多倍。这是有道理的——它们是用母语(即C)编写的，由专家创建、审查和优化。他们也更不容易出现缺陷，更有可能处理边缘和角落案例。

测试脚本

将这个答案中的所有代码片段放在一起，形成一个脚本，该脚本将运行下面描述的反向列表的不同方式。它将在运行100,000次时对每个方法进行计时。最后一节显示了长度为2、10和1000项的列表的结果。

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:使用slices反转列表obj[::-1]

内置的索引切片方法允许您复制任何索引对象的一部分。

它不影响原来的对象 它构建一个完整的列表，而不是迭代器

通用语法是:<object>[first_index:last_index:step]。使用:<list>[::-1]来创建一个简单的反向列表。当一个选项为空时，它将它们设置为对象的第一个和最后一个元素的默认值(如果步长为负则相反)。

索引允许使用负数，它从对象索引的末尾向后计数(即-2是倒数第二项)。当步长为负数时，它将从最后一项开始，并向后索引该值。

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

方法3:使用reversed(obj)迭代器函数反转列表

有一个反向的(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))

计时结果

结果表明，使用最适合于特定类型反转的内置方法，缩放效果最好。换句话说，随着对象元素数量的增加，内置方法的速度甚至超过其他方法。

直接实现所需内容的内置方法比将内容串在一起要好。例如，如果你需要反向列表的副本，切片是最好的-它比从list(reversed(obj))函数创建一个副本列表快，也比创建一个列表副本然后在原地执行obj.reverse()快，但速度永远不会超过两倍。与此同时，自定义方法对于大型列表可能需要更长数量级的时间。

对于缩放，对于一个1000项的列表，reversed(<list>)函数调用需要大约30毫秒来设置迭代器，反向只需要大约55毫秒，使用slice方法需要大约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

组织价值观:

在Python中，列表的顺序也可以通过sort操作，以数字/字母顺序组织变量: 暂时:

print(排序(my_list))

永久的:

my_list.sort(), print(my_list)

你可以用"reverse=True"来排序:

print(sorted(my_list, reverse=True))

or

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

没有组织

也许您不想对值进行排序，而只是将值反向排列。然后我们可以这样做:

print(list(reversed(my_list)))

**数字在列表顺序上优先于字母。Python价值观的组织非常棒。

编辑1:一个错误的版主声称我的答案是一个副本，并删除了我的旧帖子。

我在一次面试的python代码测试中遇到了这个问题。 以下是我的答案。 注意它适用于任何值任何长度

def get_reverse(list_check, count_num):
    final_list =[]
    for index in range(list_length):
        value = list_check[count_num]
        final_list.append(value)
        count_num = count_num -1

    return final_list

new_list = ['A', 'GOAT', 'C', 'D', 'Mac']

list_length = len(new_list)
x = list_length -1

print(get_reverse(new_list, x))

一个干净简单的类对象来解决您的问题。

class lister():
    def reverse(self):
        return  [self[len(self)-e]for e,x in enumerate(self,start=1)]
print(lister.reverse([0, 10, 20, 40]))

另一种方法使用列表理解和abs

array = [0, 10, 20, 40]

reversed_array = [array[abs(indx)] for indx in range(abs(len(array)-1),1)]
            
reversed_array
[40, 20, 10, 0]

The cute Solution


class List_reverse():
    def reverse_list(self):
        list = [1, 2, 3, 4, 5, 6]
        list1 = []
        for i in range(1, len(list)+1):
            list1.append(list[-i])
        print(list1)


if __name__ == "__main__":
    obj = List_reverse()
    obj.reverse_list()
    enter code here