answer
1373
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
Để cũng 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ó đến 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 điện và máy phát điện không thể được đảo ngược, bạn cần phải chuyển đổi nó thành một máy phát điện list
trước.
1373 hữu ích 5 bình luận chia sẻ
answer
193
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 đảo ngược danh sách trong vòng lặp for [nhưng sẽ không thực sự sửa đổi danh sách của bạn "vĩnh viễn"].
193 hữu ích 4 bình luận chia sẻ
answer
70
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
70 hữu ích 5 bình luận chia sẻ
answer
70
Nó có thể được thực hiện như thế này:
for i in range[len[collection]-1, -1, -1]:
print collection[i]
# print[collection[i]] for python 3. +
Vì vậy, dự đoán của bạn đã khá gần :] Hơi khó xử nhưng về cơ bản nó nói: bắt đầu với 1 nhỏ hơn len[collection]
, tiếp tục cho đến khi bạn đến ngay trước -1, theo từng bước của -1.
Fyi,
help
chức năng này rất hữu ích vì nó cho phép bạn xem tài liệu cho một thứ gì đó từ bảng điều khiển Python, ví dụ:
help[range]
70 hữu ích 3 bình luận chia sẻ
answer
24
Các reversed
chức năng được xây dựng trong là tiện dụng:
for item in reversed[sequence]:
Các tài liệu hướng dẫn 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 một trình tự cùng với chỉ mục [ví dụ: đối với các sửa đổi tại chỗ thay đổi độ dài trình tự], tôi có chức năng này xác định một 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 trình tự. Rõ ràng, những reversed
hạn chế vẫn được
áp dụng.
24 hữu ích 0 bình luận chia sẻ
answer
15
Một cách tiếp cận không có hàng 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]
15 hữu ích 1 bình luận chia sẻ
answer
11
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 "count" 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
11 hữu ích 2 bình luận chia sẻ
answer
10
Làm thế nào về việc 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
>>>
10 hữu ích 0 bình luận chia sẻ
answer
9
>>> l = ["a","b","c","d"]
>>> l.reverse[]
>>> l
['d', 'c', 'b', 'a']
HOẶC LÀ
>>> print l[::-1]
['d', 'c', 'b', 'a']
9 hữu ích 0 bình luận chia sẻ
answer
7
Tôi thích cách tiếp cận trình tạo một lớp lót:
[[i, sequence[i]] for i in reversed[xrange[len[sequence]]]]
7 hữu ích 0 bình luận chia sẻ
answer
4
Sử dụng list.reverse[]
và sau đó lặp lại như bạn thường làm.
//docs.python.org/tutorial/datastructures.html
4 hữu ích 1 bình luận chia sẻ
answer
4
vì 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]
4 hữu ích 1 bình luận chia sẻ
answer
4
Một cách biểu đạt để đạt được reverse[enumerate[collection]]
trong python 3:
zip[reversed[range[len[collection]]], reversed[collection]]
trong python 2:
izip[reversed[xrange[len[collection]]], reversed[collection]]
Tôi không chắc tại sao chúng ta không có cách viết tắt cho điều này, ví dụ:
def reversed_enumerate[collection]:
return zip[reversed[range[len[collection]]], reversed[collection]]
hoặc tại sao chúng tôi không có reversed_range[]
4 hữu ích 0 bình luận chia sẻ
answer
3
def reverse[spam]:
k = []
for i in spam:
k.insert[0,i]
return "".join[k]
3 hữu ích 0 bình luận chia sẻ
answer
2
chức năng đảo ngược có ích ở đây:
myArray = [1,2,3,4]
myArray.reverse[]
for x in myArray:
print x
2 hữu ích 1 bình luận chia sẻ
answer
2
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 danh sách của bạn, vì vậy nếu danh sách của bạn đang chiếm một phần lớn bộ nhớ của bạn, bạn
sẽ phải trừ đi chỉ số được trả về enumerate[reversed[]]
từ đó len[]-1
.
Nếu bạn chỉ cần làm điều đó 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áy phát điện:
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]
2 hữu ích 0 bình luận chia sẻ
answer
2
Tôi nghĩ cách thanh lịch nhất là biến đổi enumerate
và reversed
sử dụng máy phát điện
sau
[-[ri+1], val] for ri, val in enumerate[reversed[foo]]
tạo ra sự đảo ngược của enumerate
trình 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]
2 hữu ích 0 bình luận chia sẻ
answer
1
Để 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
1 hữu ích 0 bình luận chia sẻ
answer
1
Bạn cũng có thể sử dụng một while
vòng lặp:
i = len[collection]-1
while i>=0:
value = collection[i]
index = i
i-=1
1 hữu ích 0 bình luận chia sẻ
answer
1
Bạn có thể sử dụng chỉ mục âm trong 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 chỉ mục như thể bạn đang lặp lại về phía trước 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, chưa
được đảo ngược, hãy 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
1 hữu ích 0 bình luận chia sẻ
answer
1
Nếu bạn không ngại chỉ số â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
1 hữu ích 0 bình luận chia sẻ
answer
0
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 đọc hiểu Danh sách
collection = ['a','b','c']
[item for item in reversed[ collection ] ]
0 hữu ích 1 bình luận chia sẻ
answer
0
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]]]
0 hữu ích 0 bình luận chia sẻ
answer
0
input_list = ['foo','bar','baz']
for i in range[-1,-len[input_list]-1,-1]
print[input_list[i]]
tôi nghĩ cách này cũng đơn giản để làm điều đó ... đọc từ cuối và tiếp tục giảm cho đến khi độ dài của danh sách, vì chúng tôi không bao giờ thực hiện chỉ mục "kết thúc" do đó được thêm -1.
0 hữu ích 0 bình luận chia sẻ
answer
0
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 [tức là đầu tiên khi nhìn ngược lại], 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.
0 hữu ích 1 bình luận chia sẻ
answer
-1
bạn có thể sử dụng 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.
-1 hữu ích 0 bình luận chia sẻ