Pythonでリストを逆の順序でたどる
だから私はlen(collection)から始めてcollection[0]で終わることができます。
編集：申し訳ありませんが、私はまたループインデックスにアクセスできるようにしたいという言及を忘れていました。
組み込みの reversed() functionを使用します。
>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
... print(i)
...
baz
bar
foo
元のインデックスにもアクセスするには、enumerate()に渡す前に、リストで reversed() を使用します。
>>> for i, e in reversed(list(enumerate(a))):
... print(i, e)
...
2 baz
1 bar
0 foo
enumerate()はジェネレータを返し、ジェネレータは元に戻すことができないので、まずそれをlistに変換する必要があります。
できるよ：
for item in my_list[::-1]:
print item
（またはforループでやりたいことは何でも）
[::-1]スライスはforループのリストを逆にします（しかし実際にはあなたのリストを「永久に」修正することはありません）。
ループインデックスが必要で、リスト全体を2回トラバースしたくない場合、または追加のメモリを使用したくない場合は、ジェネレータを作成します。
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
それはこのようにすることができます：
範囲（len（collection）-1、-1、-1）のiの場合： print collection [i] ＃print（collection [i]）＃python 3の場合。+
それで、あなたの推測はかなり近かった:)少し厄介ですが、それは基本的に言っています：len(collection)より1小さい値から始めて、-1の直前まで-1の直前までたどり着くまで続けてください。
Fyi、help関数はPythonコンソールから何かのためのドキュメントを見ることを可能にするのでとても便利です、例えば：
help(range)
reversed組み込み関数は便利です：
for item in reversed(sequence):
ドキュメント の逆は、その制限を説明しています。
インデックスと一緒に逆方向にシーケンスを歩かなければならない場合（例えば、シーケンスの長さを変更するインプレース変更の場合）には、この関数に私のcodeutilモジュールを定義させます。
import itertools
def reversed_enumerate(sequence):
return itertools.izip(
reversed(xrange(len(sequence))),
reversed(sequence),
)
これはシーケンスのコピーを作成することを避けます。明らかに、reversedの制限がまだ適用されます。
>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']
OR
>>> print l[::-1]
['d', 'c', 'b', 'a']
私はワンライナージェネレータアプローチが好きです：
((i, sequence[i]) for i in reversed(xrange(len(sequence))))
新しいリストを作り直さずにどうすればいいですか？
>>> foo = ['1a','2b','3c','4d']
>>> for i in range(len(foo)):
... print foo[-(i+1)]
...
4d
3c
2b
1a
>>>
OR
>>> length = len(foo)
>>> for i in range(length):
... print foo[length-i-1]
...
4d
3c
2b
1a
>>>
また、 "range"または "count"関数を使うこともできます。次のように：
a = ["foo", "bar", "baz"]
for i in range(len(a)-1, -1, -1):
print(i, a[i])
3 baz
2 bar
1 foo
以下のようにitertoolsの "count"を使うこともできます。
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
list.reverse()を使用してから、通常どおりに繰り返します。
価値があるものなら、このようにできます。とても簡単です。
a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
x += 1
print a[-x]
def reverse(spam):
k = []
for i in spam:
k.insert(0,i)
return "".join(k)
簡単な方法は次のとおりです。
for i in range(1,len(arr)+1):
print(arr[-i])
索引が必要で、リストが小さい場合、最も読みやすい方法は、受け入れられている回答のようにreversed(list(enumerate(your_list)))を実行することです。しかし、これはあなたのリストのコピーを作成するので、あなたのリストがあなたのメモリの大部分を占めているならば、あなたはenumerate(reversed())からlen()-1によって返されるインデックスを引かなければなりません。
あなたが一度だけそれをする必要があるならば：
a = ['b', 'd', 'c', 'a']
for index, value in enumerate(reversed(a)):
index = len(a)-1 - index
do_something(index, value)
あるいは、これを複数回行う必要がある場合は、ジェネレータを使用する必要があります。
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)
他の答えは良いですが、あなたが リスト内包スタイルとしてやりたいのなら
collection = ['a','b','c']
[item for item in reversed( collection ) ]
Python 3でreverse(enumerate(collection))を実現するための表現的な方法：
Zip(reversed(range(len(collection))), reversed(collection))
python 2では：
izip(reversed(xrange(len(collection))), reversed(collection))
なぜ私達がこれのための省略表現を持っていないのかわかりません、例えば。
def reversed_enumerate(collection):
return Zip(reversed(range(len(collection))), reversed(collection))
それともreversed_range()がないのか
通常のforループで負のインデックスを使うことができます。
>>> collection = ["ham", "spam", "eggs", "baked beans"]
>>> for i in range(1, len(collection) + 1):
... print(collection[-i])
...
baked beans
eggs
spam
ham
コレクションの反転コピーを順方向に繰り返し処理しているかのようにインデックスにアクセスするには、i - 1を使用します。
>>> for i in range(1, len(collection) + 1):
... print(i-1, collection[-i])
...
0 baked beans
1 eggs
2 spam
3 ham
元の非反転インデックスにアクセスするには、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
whileループを使うこともできます。
i = len(collection)-1
while i>=0:
value = collection[i]
index = i
i-=1
シーケンスオブジェクトに組み込み関数reversed()を使用します。このメソッドはすべてのシーケンスの効果を持ちます。
a = ["foo", "bar", "baz"]
print a[::~0]
この問題を解決するもう1つの方法は、このコードはループのために減少して実行される
逆関数はここで役に立ちます：
myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
print x
タスクがリストの中のある条件を満たす最後の要素を見つけることであると仮定すると（すなわち、後ろ向きに見ると最初に）、私は以下の数を得ています。
>>> 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
だから、最も醜いオプションxrange(len(xs)-1,-1,-1)が最速です。
負のインデックスを使用するには、-1から始めて、反復ごとに-1ずつ戻ります。
>>> a = ["foo", "bar", "baz"]
>>> for i in range(-1, -1*(len(a)+1), -1):
... print i, a[i]
...
-1 baz
-2 bar
-3 foo
input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
print(input_list[i])
これも簡単な方法だと思います。最後から読んでlistの長さまでデクリメントし続けます。これは "end"インデックスを実行しないので-1も追加されるためです。
私は最もエレガントな方法は次のジェネレータを使ってenumerateとreversedを変換することだと思います
(-(ri+1), val) for ri, val in enumerate(reversed(foo))
これはenumerateイテレータの逆を生成します
例：
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)))
]
結果：
[6, 4, 2]
簡単な方法：
n = int(input())
arr = list(map(int, input().split()))
for i in reversed(range(0, n)):
print("%d %d" %(i, arr[i]))
インデックスが負であることを気にしないのであれば、次のようにします。
>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
... print(~i, a[~i]))
-1 baz
-2 bar
-3 foo