Python でリストを逆順に走査する

Question

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

編集：申し訳ありませんが、ループインデックスにもアクセスできるようにしたいと言うのを忘れていました。

Answer 1

を使用ビルトイン 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に変換する必要があり、元に戻すことはできません。

Answer 2

あなたが行うことができます：

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

（または任意のforループでやりたい。）

[::-1]スライスは、ループの中にリストを反転させる（しかし、実際には「永久に」あなたのリストは変更されません）。

Answer 3

あなたがループインデックスを必要とし、二回リスト全体を横断し、あるいは余分なメモリを使用しない場合は、

は、私が発電機を記述します。

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

Answer 4

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

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

    # print(collection[i]) for python 3. +

だからあなたの推測では、:)かなり近かった少しぎこちないが、基本的に言っている：-1の段階で、あなただけの前-1に到達するまで続ける、len(collection)より1少ないで始まります。

ちなみに、help機能は、それはあなたがPythonのコンソールから何かのためにドキュメントを表示することができますように非常に有用である、例えばます：

help(range)

Answer 5

reversed組み込み関数が便利です。

for item in reversed(sequence):

逆転のためのドキュメントには、その限界を説明します。

Iインデックスと共に逆配列を歩かなければならない場合のために（例えば系列長を変えるインプレース修正のために）、私は、この関数は私codeutilモジュールを定義している：

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

この1は、配列のコピーを作成避けることができます。もちろん、reversedの制限がまだ適用されます。

Answer 6

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

または

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

Answer 7

どのように新しいリストを再作成しなくても、あなたがインデックスによって行うことができますについてます：

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

Answer 8

私はワンライナー・ジェネレータのアプローチを好むます：

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

Answer 9

また、あなたは「範囲」または「カウント」の機能のいずれかを使用することができます。 次のように：

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

3 baz
2 bar
1 foo

また、次のようitertoolsから "カウント" を使用することができます：

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

Answer 10

list.reverse()を使用して、通常どおりに反復します。

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

Answer 11

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

Answer 12

それはあなたも、このようにそれを行うことができます価値が今まで何のため。非常に単純ます。

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

Answer 13

あなたは、インデックスを必要とし、あなたのリストが小さい場合は、

、最も読みやすい方法は受け入れ答えが言うよう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)

Answer 14

リバース機能は、ここでは便利です。

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

Answer 15

他の答えは良いですが、次のようにしたい場合はリスト理解スタイル

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

Answer 16

シーケンス・オブジェクトの

使用組み込み関数reversed()は、この方法は、全ての配列の効果を有する

より詳細な参照リンクの

Answer 17

またwhileループを使用することができます：

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

Answer 18

あなたはループのために、通常では負のインデックスを使用することができます：

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

Answer 19

の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()を持っていない理由

Answer 20

なしの輸入とアプローチます：

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

または

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

Answer 21

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

Answer 22

簡単な方法：

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

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

Answer 23

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

私は端から見る...この1つはまたそれを行うための簡単な方法だと思うし、我々はそれゆえ、「終わり」のインデックスを実行したことがないため、リストの長さまでデクリメントを保つ追加-1も

Answer 24

タスクが（すなわち、最初の後方を見たときに）リスト内のいくつかの条件を満たした最後の要素を見つけることです、私は次の番号を取得していますと仮定すると、

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

Answer 25

あなたは、インデックスが負であることを気にしない場合は、あなたが行うことができます：

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

Answer 26

私が最もエレガントな方法は、以下の発電機を使用して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]