Pythonで逆順でリストをトラバースする

だから私はから始めてlen(collection)終わりにすることができcollection[0]ます。

また、ループインデックスにアクセスできるようにしたいと考えています。

組み込みreversed()関数を使用します。

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

これは次のように行うことができます：

for i for range（len（collection）-1、-1、-1）：
    コレクションを印刷[i]

    ＃python 3のprint（collection [i]）+

だからあなたの推測はかなり近かったです:)少しぎこちないですが、それは基本的に言っています：1より小さいから始め、len(collection)-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制限はまだ適用されます。

新しいリストを再作成せずに、インデックスを作成することで実現できます。

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

または

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

または

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

私はワンライナージェネレーターアプローチが好きです：

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

また、「範囲」または「カウント」関数を使用できます。次のように：

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()通常どおりに使用してから繰り返します。

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

インポートなしのアプローチ：

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

または

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

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

どんなに価値があるとしても、このようにそれを行うことができます。とてもシンプル。

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

reverse(enumerate(collection))Python 3で表現する方法：

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

インデックスが必要で、リストが小さい場合、最も読みやすい方法は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)

ここでは、reverse関数が便利です。

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

whileループを使用することもできます。

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

通常の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

インデックスが負でも構わない場合は、次のようにできます。

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

最もエレガントな方法は、次のジェネレータを変換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]

他の答えは良いですが、リスト内包表記スタイルとしてやりたい場合

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

負のインデックスを使用するには、-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

簡単な方法：

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

これも簡単な方法だと思います...末尾から読み取り、リストの長さまでデクリメントを続けます。これは、「end」インデックスを実行しないため、-1も追加されたためです。

タスクがリスト内のいくつかの条件を満たす最後の要素を見つけることであると仮定すると（つまり、後ろ向きに見たときに最初に）、次の数値が得られます。

>>> 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)が最速です。

あなたはジェネレータを使うことができます：

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

最終的に：

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

これがお役に立てば幸いです。