Python'da bir listeyi ters sırada döndürme

Böylece başlayıp len(collection)bitebilirim collection[0].

Ayrıca döngü dizinine erişmek istiyorum.

Yerleşik reversed()işlevi kullanın :

>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
...     print(i)
... 
baz
bar
foo

Orijinal dizine erişmek için enumerate(), listeye iletmeden önce listenizde kullanın reversed():

>>> for i, e in reversed(list(enumerate(a))):
...     print(i, e)
... 
2 baz
1 bar
0 foo

Yana enumerate()döner bir jeneratör ve jeneratörler geri alınamaz, bir dönüştürmek için gereken listilk.

Yapabilirsin:

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

(Ya da for döngüsünde ne yapmak isterseniz.)

[::-1]Dilim döngü listeyi tersine çevirir (ancak reklamları listesi "kalıcı" değiştirmez).

Döngü dizinine ihtiyacınız varsa ve tüm listeyi iki kez dolaşmak veya fazladan bellek kullanmak istemiyorsanız, bir jeneratör yazarım.

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

Bu şekilde yapılabilir:

aralıktaki i için (len (toplama) -1, -1, -1):
    koleksiyonu yazdır [i]

    python 3 için # print (koleksiyon [i]). +

Yani tahmininiz oldukça yakındı :) Biraz garip ama temelde şöyle diyor: 1'den daha az ile başlayın, len(collection)-1'den hemen önce -1'e kadar olana kadar devam edin.

Fyi, helpişlev Python konsolundan bir şey için dokümanları görüntülemenize izin verdiği için çok kullanışlıdır, örneğin:

help(range)

reversedYerleşik fonksiyonu kullanışlıdır:

for item in reversed(sequence):

Dokümantasyon ters yönelik sınırlamaları açıklar.

Bir dizini dizin ile birlikte ters bir şekilde yürümek zorunda olduğu durumlarda (örneğin, sıra uzunluğunu değiştiren yerinde değişiklikler için), bu işlev benim bir kodutil modülü tanımladı:

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

Bu, dizinin bir kopyasını oluşturmaktan kaçınır. Açıkçası, reversedsınırlamalar hala geçerlidir.

Yeni bir liste oluşturmadan, dizine ekleyerek yapabilirsiniz:

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

VEYA

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

VEYA

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

Tek katmanlı jeneratör yaklaşımını seviyorum:

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

Ayrıca, "aralık" veya "sayma" işlevlerinden birini kullanabilirsiniz. Aşağıdaki gibi:

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

3 baz
2 bar
1 foo

Ayrıca itertools "count" kullanabilirsiniz aşağıdaki gibi:

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()Normal şekilde yaptığınız gibi kullanın ve tekrarlayın.

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

İthalatı olmayan bir yaklaşım:

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

veya

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

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

ne kadar değerli olursa olsun böyle yapabilirsiniz. Çok basit.

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

reverse(enumerate(collection))Python 3'te başarmanın etkileyici bir yolu :

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

python 2'de:

izip(reversed(xrange(len(collection))), reversed(collection))

Bunun için neden kestirme bir elimiz olmadığından emin değilim, örneğin:

def reversed_enumerate(collection):
    return zip(reversed(range(len(collection))), reversed(collection))

ya da neden sahip değiliz reversed_range()

Dizine ihtiyacınız varsa ve listeniz küçükse, en okunaklı yol reversed(list(enumerate(your_list)))kabul edilen yanıtın söylediği gibi yapmaktır . Ama bu liste sizin belleğin büyük bir bölümünü kaplıyor yüzden eğer tarafından döndürülen dizini çıkarmak gerekecek, listenizin bir kopyasını oluşturur enumerate(reversed())dan len()-1.

Sadece bir kez yapmanız gerekiyorsa:

a = ['b', 'd', 'c', 'a']

for index, value in enumerate(reversed(a)):
    index = len(a)-1 - index

    do_something(index, value)

veya bunu birkaç kez yapmanız gerekiyorsa bir jeneratör kullanmalısınız:

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)

ters fonksiyon burada işe yarar:

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

Ayrıca bir whiledöngü de kullanabilirsiniz :

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

Sıradan bir döngü için negatif bir dizin kullanabilirsiniz:

>>> collection = ["ham", "spam", "eggs", "baked beans"]
>>> for i in range(1, len(collection) + 1):
...     print(collection[-i])
... 
baked beans
eggs
spam
ham

Dizine, koleksiyonun ters çevrilmiş bir kopyası üzerinde ileri doğru yineleniyormuş gibi erişmek için şunu kullanın i - 1:

>>> for i in range(1, len(collection) + 1):
...     print(i-1, collection[-i])
... 
0 baked beans
1 eggs
2 spam
3 ham

Orijinal, ters çevrilmemiş dizine erişmek için şunu kullanın 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

Dizinin negatif olduğunu düşünmüyorsanız şunları yapabilirsiniz:

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

Bence en zarif yol şu jeneratörü dönüştürmek enumerateve reversedkullanmak

(-(ri+1), val) for ri, val in enumerate(reversed(foo))

enumerateyineleyicinin tersini oluşturur

Misal:

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

Sonuç:

[6, 4, 2]

Diğer cevaplar iyidir, ancak Liste anlama stili olarak yapmak istiyorsanız

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

Negatif indeksleri kullanmak için: -1 ile başlayın ve her yinelemede -1 ile geriye gidin.

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

Basit bir yol:

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

Ben bu da bunu yapmak için basit bir yol olduğunu düşünüyorum ... sonuna kadar okuyun ve liste uzunluğuna kadar azalan tutmak, çünkü biz asla "son" endeksi yürütmek dolayısıyla -1 de eklendi

Görevin bir listede (yani geriye doğru bakarken ilk) bazı koşulları karşılayan son elemanı bulmak olduğunu varsayarsak, aşağıdaki sayıları alıyorum:

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

Yani, en çirkin seçenek xrange(len(xs)-1,-1,-1)en hızlısıdır.

bir jeneratör kullanabilirsiniz:

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

en sonunda:

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

Umarım bu sana yardımcı olur.