Di chuyển một danh sách theo thứ tự ngược lại trong Python

Vì vậy, tôi có thể bắt đầu từ len(collection)và kết thúc collection[0].

Tôi cũng muốn có thể truy cập vào chỉ số vòng lặp.

Sử dụng reversed()chức năng tích hợp:

>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
...     print(i)
... 
baz
bar
foo

Để truy cập chỉ mục gốc, hãy sử dụng enumerate()trong danh sách của bạn trước khi chuyển nó tới reversed():

>>> for i, e in reversed(list(enumerate(a))):
...     print(i, e)
... 
2 baz
1 bar
0 foo

Vì enumerate()trả về một máy phát và máy phát không thể đảo ngược, bạn cần chuyển đổi nó thành máy phát listtrước.

Bạn có thể làm:

for item in my_list[::-1]:
    print item

(Hoặc bất cứ điều gì bạn muốn làm trong vòng lặp for.)

Các [::-1]lát cắt đảo ngược danh sách trong vòng lặp for (nhưng thực tế sẽ không sửa đổi danh sách của bạn "vĩnh viễn").

Nếu bạn cần chỉ mục vòng lặp và không muốn duyệt qua toàn bộ danh sách hai lần hoặc sử dụng thêm bộ nhớ, tôi sẽ viết một trình tạo.

def reverse_enum(L):
   for index in reversed(xrange(len(L))):
      yield index, L[index]

L = ['foo', 'bar', 'bas']
for index, item in reverse_enum(L):
   print index, item

Nó có thể được thực hiện như thế này:

cho i trong phạm vi (len (bộ sưu tập) -1, -1, -1):
    bộ sưu tập in [i]

    # in (bộ sưu tập [i]) cho python 3. +

Vì vậy, dự đoán của bạn đã khá gần :) Một chút lúng túng nhưng về cơ bản nó nói: bắt đầu với 1 ít hơn len(collection), tiếp tục cho đến khi bạn đến ngay trước -1, theo các bước của -1.

Fyi, helpchức năng này rất hữu ích vì nó cho phép bạn xem các tài liệu cho một cái gì đó từ bảng điều khiển Python, ví dụ:

help(range)

Hàm reverseddựng sẵn rất tiện dụng:

for item in reversed(sequence):

Các tài liệu cho đảo ngược giải thích những hạn chế của nó.

Đối với các trường hợp tôi phải đi ngược lại trình tự cùng với chỉ mục (ví dụ: để sửa đổi tại chỗ thay đổi độ dài chuỗi), tôi có chức năng này xác định mô-đun codeutil của tôi:

import itertools
def reversed_enumerate(sequence):
    return itertools.izip(
        reversed(xrange(len(sequence))),
        reversed(sequence),
    )

Điều này tránh tạo ra một bản sao của chuỗi. Rõ ràng, những reversedhạn chế vẫn được áp dụng.

Làm thế nào về mà không tạo lại một danh sách mới, bạn có thể làm bằng cách lập chỉ mục:

>>> foo = ['1a','2b','3c','4d']
>>> for i in range(len(foo)):
...     print foo[-(i+1)]
...
4d
3c
2b
1a
>>>

HOẶC LÀ

>>> length = len(foo)
>>> for i in range(length):
...     print foo[length-i-1]
...
4d
3c
2b
1a
>>>

>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']

HOẶC LÀ

>>> print l[::-1]
['d', 'c', 'b', 'a']

Tôi thích cách tiếp cận máy phát điện một lớp:

((i, sequence[i]) for i in reversed(xrange(len(sequence))))

Ngoài ra, bạn có thể sử dụng các hàm "phạm vi" hoặc "đếm". Như sau:

a = ["foo", "bar", "baz"]
for i in range(len(a)-1, -1, -1):
    print(i, a[i])

3 baz
2 bar
1 foo

Bạn cũng có thể sử dụng "đếm" từ itertools như sau:

a = ["foo", "bar", "baz"]
from itertools import count, takewhile

def larger_than_0(x):
    return x > 0

for x in takewhile(larger_than_0, count(3, -1)):
    print(x, a[x-1])

3 baz
2 bar
1 foo

Sử dụng list.reverse()và sau đó lặp đi lặp lại như bình thường.

http://docs.python.org/tutorial/datastructures.html

Một cách tiếp cận không có nhập khẩu:

for i in range(1,len(arr)+1):
    print(arr[-i])

hoặc là

for i in arr[::-1]:
    print(i)

def reverse(spam):
    k = []
    for i in spam:
        k.insert(0,i)
    return "".join(k)

cho những gì đáng giá bạn cũng có thể làm như thế này. rất đơn giản.

a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
    x += 1
    print a[-x]

Một cách biểu cảm để đạt được reverse(enumerate(collection))trong python 3:

zip(reversed(range(len(collection))), reversed(collection))

trong trăn 2:

izip(reversed(xrange(len(collection))), reversed(collection))

Tôi không chắc tại sao chúng ta không có một tốc ký cho việc này, vd.:

def reversed_enumerate(collection):
    return zip(reversed(range(len(collection))), reversed(collection))

hoặc tại sao chúng ta không có reversed_range()

Nếu bạn cần chỉ mục và danh sách của bạn nhỏ, cách dễ đọc nhất là làm reversed(list(enumerate(your_list)))như câu trả lời được chấp nhận nói. Nhưng điều này tạo ra một bản sao của danh sách của bạn, vì vậy nếu danh sách của bạn chiếm một phần lớn bộ nhớ, bạn sẽ phải trừ chỉ mục được trả về enumerate(reversed())từlen()-1 .

Nếu bạn chỉ cần làm một lần:

a = ['b', 'd', 'c', 'a']

for index, value in enumerate(reversed(a)):
    index = len(a)-1 - index

    do_something(index, value)

hoặc nếu bạn cần làm điều này nhiều lần, bạn nên sử dụng một trình tạo:

def enumerate_reversed(lyst):
    for index, value in enumerate(reversed(lyst)):
        index = len(lyst)-1 - index
        yield index, value

for index, value in enumerate_reversed(a):
    do_something(index, value)

chức năng đảo ngược có ích ở đây:

myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
    print x

Bạn cũng có thể sử dụng một whilevòng lặp:

i = len(collection)-1
while i>=0:
    value = collection[i]
    index = i
    i-=1

Bạn có thể sử dụng một chỉ mục tiêu cực trong một vòng lặp for thông thường:

>>> collection = ["ham", "spam", "eggs", "baked beans"]
>>> for i in range(1, len(collection) + 1):
...     print(collection[-i])
... 
baked beans
eggs
spam
ham

Để truy cập vào chỉ mục như thể bạn đang lặp đi lặp lại qua một bản sao đảo ngược của bộ sưu tập, hãy sử dụng i - 1:

>>> for i in range(1, len(collection) + 1):
...     print(i-1, collection[-i])
... 
0 baked beans
1 eggs
2 spam
3 ham

Để truy cập chỉ mục gốc, không đảo ngược, sử dụng len(collection) - i:

>>> for i in range(1, len(collection) + 1):
...     print(len(collection)-i, collection[-i])
... 
3 baked beans
2 eggs
1 spam
0 ham

Nếu bạn không nhớ chỉ số là âm, bạn có thể làm:

>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
...     print(~i, a[~i]))
-1 baz
-2 bar
-3 foo

Tôi nghĩ rằng cách thanh lịch nhất là chuyển đổi enumeratevà reversedsử dụng trình tạo sau

(-(ri+1), val) for ri, val in enumerate(reversed(foo))

tạo ra sự đảo ngược của enumeratetrình vòng lặp

Thí dụ:

foo = [1,2,3]
bar = [3,6,9]
[
    bar[i] - val
    for i, val in ((-(ri+1), val) for ri, val in enumerate(reversed(foo)))
]

Kết quả:

[6, 4, 2]

Các câu trả lời khác là tốt, nhưng nếu bạn muốn làm theo kiểu hiểu danh sách

collection = ['a','b','c']
[item for item in reversed( collection ) ]

Để sử dụng các chỉ số phủ định: bắt đầu ở -1 và lùi lại -1 ở mỗi lần lặp.

>>> a = ["foo", "bar", "baz"]
>>> for i in range(-1, -1*(len(a)+1), -1):
...     print i, a[i]
... 
-1 baz
-2 bar
-3 foo

Một cách đơn giản:

n = int(input())
arr = list(map(int, input().split()))

for i in reversed(range(0, n)):
    print("%d %d" %(i, arr[i]))

input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
    print(input_list[i])

Tôi nghĩ rằng đây cũng là một cách đơn giản để làm điều đó ... đọc từ cuối và tiếp tục giảm dần cho đến khi danh sách kéo dài, vì chúng tôi không bao giờ thực hiện chỉ số "kết thúc" do đó cũng thêm -1

Giả sử nhiệm vụ là tìm phần tử cuối cùng thỏa mãn một số điều kiện trong danh sách (nghĩa là lần đầu tiên khi nhìn về phía sau), tôi nhận được các số sau:

>>> min(timeit.repeat('for i in xrange(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
4.6937971115112305
>>> min(timeit.repeat('for i in reversed(xrange(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
4.809093952178955
>>> min(timeit.repeat('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
4.931743860244751
>>> min(timeit.repeat('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
5.548468112945557
>>> min(timeit.repeat('for i in xrange(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', repeat=8))
6.286104917526245
>>> min(timeit.repeat('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
8.384078979492188

Vì vậy, lựa chọn xấu nhất xrange(len(xs)-1,-1,-1)là nhanh nhất.

bạn có thể sử dụng một máy phát điện:

li = [1,2,3,4,5,6]
len_li = len(li)
gen = (len_li-1-i for i in range(len_li))

cuối cùng:

for i in gen:
    print(li[i])

Hy vọng điều này sẽ giúp bạn.