Перемещение по списку в обратном порядке в Python

Используйте встроенную функцию 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 (но фактически не изменяет ваш список «навсегда»).

Сделать это можно так:

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

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

Итак, ваша догадка была довольно близкой :) Немного неудобно, но в основном она гласит: начните с 1 меньше, чем len(collection), продолжайте, пока не дойдете до значения непосредственно перед -1, с шагом -1.

К вашему сведению, функция help очень полезна, поскольку позволяет просматривать документы для чего-либо из консоли Python, например:

help(range)

Если вам нужен индекс цикла и вы не хотите дважды проходить весь список или использовать дополнительную память, я бы написал генератор.

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

Встроенная функция reversed удобна:

for item in reversed(sequence):

В документации для reverse объясняются его ограничения.

Для случаев, когда мне нужно пройти последовательность в обратном порядке вместе с индексом (например, для модификаций на месте, изменяющих длину последовательности), у меня есть эта функция, определяющая мой модуль codeutil:

from six.moves import zip as izip, range as xrange

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

Это позволяет избежать создания копии последовательности. Очевидно, что reversed ограничения все еще применяются.

Подход без импорта:

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

or

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

Кроме того, вы можете использовать функции «диапазона» или «подсчета». Следующее:

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

3 baz
2 bar
1 foo

Вы также можете использовать "count" из 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

Как насчет того, чтобы не создавать новый список, вы можете обойтись путем индексации:

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

Мне нравится однострочный генератор:

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

В python 3 список создает копию, поэтому reversed(list(enumerate(collection)) может быть неэффективным, поскольку создание другого списка не оптимизируется.

Если коллекция точно является списком, то лучше всего скрыть сложность за итератором.

def reversed_enumerate(collection: list):
    for i in range(len(collection)-1, -1, -1):
        yield i, collection[i]

Итак, самый чистый:

for i, elem in reversed_enumerate(['foo', 'bar', 'baz']):
    print(i, elem)

Используйте list.reverse(), а затем повторите, как обычно.

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

во что бы то ни стало, вы тоже можете это сделать. очень простой.

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

здесь пригодится обратная функция:

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

Если вам нужен индекс, а ваш список невелик, наиболее читаемый способ - сделать 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)

Я думаю, что самый элегантный способ - преобразовать 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]

Чтобы использовать отрицательные индексы: начните с -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

Вы также можете использовать цикл 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

Предполагая, что задача состоит в том, чтобы найти последний элемент, который удовлетворяет некоторому условию в списке (т.е. первый при взгляде назад), я получаю следующие числа:

>>> 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) - самый быстрый.

Если вы не возражаете против отрицательного значения индекса, вы можете:

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

Другие ответы хороши, но если вы хотите использовать стиль понимания списка

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

Простой способ:

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 также

вы можете использовать генератор:

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

надеюсь, это поможет вам.