파이썬에서 목록을 역순으로 순회

그래서 시작 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 루프의 목록을 반전 (실제로 목록 "영구적"을 수정하지 않습니다).

루프 인덱스가 필요하고 전체 목록을 두 번 탐색하거나 추가 메모리를 사용하지 않으려면 생성기를 작성하십시오.

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

다음과 같이 할 수 있습니다 :

범위 내 i의 경우 (len (collection) -1, -1, -1) :
    인쇄 수집 [i]

    파이썬 3에 대한 # print (collection [i])

그래서 당신의 추측은 꽤 가까웠습니다 :) 약간 어색하지만 기본적으로 말합니다 : 1 미만으로 시작하고 len(collection)-1 바로 전에 -1 단계까지 갈 때까지 계속하십시오.

참고로, help함수는 파이썬 콘솔에서 무언가에 대한 문서를 볼 수 있기 때문에 매우 유용합니다.

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

또한 "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()평소처럼 사용 하고 반복 하십시오 .

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))파이썬 3에서 표현하는 표현 방법 :

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

파이썬 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)

역 기능은 여기에 유용합니다 :

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

나는 이것도 그것을 할 수있는 간단한 방법이라고 생각합니다. 끝에서 읽고 목록의 길이까지 계속 줄입니다. 우리는 "끝"인덱스를 실행하지 않기 때문에 -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])

이것이 당신을 돕기를 바랍니다.