python 列表倒序输出

#使用reverse
li1 = [1, 6, 4, 3, 7, 9]
li2 = ['a', 'm', 's', 'g']
li1.reverse()
li2.reverse()
print(li1, li2)



# 利用list切片
li1 = [1, 6, 4, 3, 7, 9]
li2 = ['a', 'm', 's', 'g']
print(li1[::-1])
print(li2[::-1])


#利用算法进行转换，这里需要用到深层copy：
import copy
li2 = ['a', 'm', 's', 'g']
li3 = copy.deepcopy(li2)
count = len(li2)
for i in li2:
    if count > 0:
        li2[int(li3.index(i))] = li3[count - 1]
        count -= 1
print(li2)

方法一:  通过切片来实现列表倒序

    list =[1,2,3,4,5,6]
    list1=list[::-1]
    print (list1)

方法二: 通过reverse() 函数用于反向列表中元素

    aList = [123, 'xyz', 'zara', 'abc', 'xyz']
    aList.reverse()
    print(aList)

方法三: sort() 函数用于对原列表进行排序

list.sort(cmp=None, key=None, reverse=False)

• cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）

    bList= ['a', 'b', 'C', 'd']
    bList.sort(reverse=True)
    print(bList)

Python列表倒序输出及其效率

方法一

使用Python内置函数reversed（）

for i in reversed(arr): pass

reversed返回的是迭代器，所以不用担心内存问题。

方法二

使用range()倒序

for i in range(len(arr) - 1, -1, -1): pass

方法三

先使用list自带的reverse()函数，再用range()循环

arr.reverse()

for i in range(len(arr)): pass

因为要先倒序，再循环，所以效率会比较低。

方法四

先使用list自带的sort()函数来倒序，再用range()循环

arr.sort(reverse=True)

for i in range(len(arr)): pass

因为要先排序，再循环，所以效率会比较低。

这里不讨论Python内置函数sorted()，它的效率比list自带的sort()函数要慢。

效率

对比代码

import time

arr = [x for x in range(10000000)]

arr1 = arr.copy()

start = time.process_time()

for i in reversed(arr): pass

end = time.process_time()

print('方法一（reversed）：', end - start)

start = time.process_time()

for i in range(len(arr) - 1, -1, -1): pass

end = time.process_time()

print('方法二（range倒序）：', end - start)

start = time.process_time()

arr.reverse()

for i in range(len(arr)): pass

end = time.process_time()

print('方法三（先reverse再range）：', end - start)

start = time.process_time()

arr1.sort(reverse=True)

for i in range(len(arr1)): pass

end = time.process_time()

print('方法四（先sort再range）：', end - start)

对比结果

数组长度为一百万时（跑了三次）：

数组长度为一千万时（跑了两次）：

数组长度为一亿时（跑了两次）：

结论

效率：方法一 > 方法二 > 方法三 > 方法四

然而并不差多少emmm

但还是尽量使用迭代器吧，数据量很大的时候不用迭代器的话有可能会占用过多的内存。