zodat ik kan beginnen met len(collection)en eindigen in collection[0].
Ik wil ook toegang krijgen tot de lus-index.
Antwoord 1, Autoriteit 100%
Gebruik de ingebouwde reversed()Functie:
>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
... print(i)
...
baz
bar
foo
Om ook toegang te krijgen tot de oorspronkelijke index, gebruik enumerate()op uw lijst voordat u deze doorgeeft aan reversed():
>>> for i, e in reversed(list(enumerate(a))):
... print(i, e)
...
2 baz
1 bar
0 foo
Sinds enumerate()retourneert een generator en generatoren kunnen niet worden omgekeerd, u moet deze converteren naar een listeerst.
Antwoord 2, Autoriteit 14%
u kunt doen:
for item in my_list[::-1]:
print item
(of wat u maar wilt doen in de voor lus.)
De [::-1]Slice Draait de lijst in de voorlus (maar wijzigt u uw lijst niet “permanent”).
Antwoord 3, Autoriteit 6%
het kan zo worden gedaan:
for i in range(len(collection)-1, -1, -1):
print collection[i]
# print(collection[i]) for python 3. +
Dus je gok was redelijk dichtbij 🙂 Een beetje onhandig, maar het zegt eigenlijk: begin met 1 minder dan len(collection), ga door tot je net voor -1 bent, in stappen van -1.
Ter info, de functie helpis erg handig omdat je hiermee de documenten voor iets uit de Python-console kunt bekijken, bijvoorbeeld:
help(range)
Antwoord 4, autoriteit 5%
Als je de loop-index nodig hebt en niet de hele lijst twee keer wilt doorlopen, of extra geheugen wilt gebruiken, zou ik een generator schrijven.
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
Antwoord 5, autoriteit 2%
De reversedingebouwde functie is handig:
for item in reversed(sequence):
De documentatievoor reversed legt de beperkingen uit.
Voor de gevallen waarin ik een reeks in omgekeerde richting met de index moet lopen (bijvoorbeeld voor wijzigingen ter plaatse die de lengte van de reeks wijzigen), heb ik deze functie gedefinieerd in een my codeutil-module:
from six.moves import zip as izip, range as xrange
def reversed_enumerate(sequence):
return izip(
reversed(xrange(len(sequence))),
reversed(sequence),
)
Deze vermijdt het maken van een kopie van de reeks. Uiteraard zijn de reversedbeperkingen nog steeds van toepassing.
Antwoord 6
Een aanpak zonder import:
for i in range(1,len(arr)+1):
print(arr[-i])
of
for i in arr[::-1]:
print(i)
Antwoord 7
U kunt ook de functies “bereik” of “tel” gebruiken.
Als volgt:
a = ["foo", "bar", "baz"]
for i in range(len(a)-1, -1, -1):
print(i, a[i])
3 baz
2 bar
1 foo
U kunt ook “count” van itertools als volgt gebruiken:
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
Antwoord 8
Zonder een nieuwe lijst te maken, kunt u het volgende doen door te indexeren:
>>> foo = ['1a','2b','3c','4d']
>>> for i in range(len(foo)):
... print foo[-(i+1)]
...
4d
3c
2b
1a
>>>
OF
>>> length = len(foo)
>>> for i in range(length):
... print foo[length-i-1]
...
4d
3c
2b
1a
>>>
Antwoord 9
>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']
OF
>>> print l[::-1]
['d', 'c', 'b', 'a']
Antwoord 10
Ik hou van de one-liner generator-aanpak:
((i, sequence[i]) for i in reversed(xrange(len(sequence))))
Antwoord 11
In Python 3, de lijst maakt een kopie, dus reversed(list(enumerate(collection))kan inefficiënt zijn, waardoor een andere lijst is geoptimaliseerd.
Als verzameling zeker een lijst is, dan is het misschien het beste om de complexiteit achter een iterator
te verbergen
def reversed_enumerate(collection: list):
for i in range(len(collection)-1, -1, -1):
yield i, collection[i]
Dus, de schoonste is:
for i, elem in reversed_enumerate(['foo', 'bar', 'baz']):
print(i, elem)
Antwoord 12
Gebruik list.reverse()en vervolgens gecharmeerd als u normaal zou doen.
http://docs.python.org/tutorial/DatAstructures.html
Antwoord 13
Want wat het ooit waard is, kan het ook dit doen. heel eenvoudig.
a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
x += 1
print a[-x]
Antwoord 14
def reverse(spam):
k = []
for i in spam:
k.insert(0,i)
return "".join(k)
Antwoord 15
De omgekeerde functie wordt hier in de hand geleverd:
myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
print x
Antwoord 16
Als je de index nodig hebt en je lijst is klein, dan is de meest leesbare manier om reversed(list(enumerate(your_list)))te doen zoals het geaccepteerde antwoord zegt. Maar dit maakt een kopie van uw lijst, dus als uw lijst een groot deel van uw geheugen in beslag neemt, moet u de index die wordt geretourneerd door enumerate(reversed())aftrekken van len()-1.
Als je het maar één keer hoeft te doen:
a = ['b', 'd', 'c', 'a']
for index, value in enumerate(reversed(a)):
index = len(a)-1 - index
do_something(index, value)
of als u dit meerdere keren moet doen, moet u een generator gebruiken:
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)
Antwoord 17
Ik denk dat de meest elegante manier is om enumerateen reversedte transformeren met behulp van de volgende generator
(-(ri+1), val) for ri, val in enumerate(reversed(foo))
die het omgekeerde van de enumerateiterator genereert
Voorbeeld:
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)))
]
Resultaat:
[6, 4, 2]
Antwoord 18
Om negatieve indices te gebruiken: begin bij -1 en stap -1 terug bij elke iteratie.
>>> a = ["foo", "bar", "baz"]
>>> for i in range(-1, -1*(len(a)+1), -1):
... print i, a[i]
...
-1 baz
-2 bar
-3 foo
Antwoord 19
U kunt ook een whilelus:
i = len(collection)-1
while i>=0:
value = collection[i]
index = i
i-=1
Antwoord 20
U kunt een negatieve index gebruiken in een gewoon voor lus:
>>> collection = ["ham", "spam", "eggs", "baked beans"]
>>> for i in range(1, len(collection) + 1):
... print(collection[-i])
...
baked beans
eggs
spam
ham
Om toegang te krijgen tot de index alsof u met een omgekeerde kopie van de collectie naar voren was, gebruik dan i - 1:
>>> for i in range(1, len(collection) + 1):
... print(i-1, collection[-i])
...
0 baked beans
1 eggs
2 spam
3 ham
Gebruik 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
Antwoord 21
Actieve taak is om het laatste element te vinden dat voldoet aan een bepaalde voorwaarde in een lijst (d.w.z. eerst wanneer ik achteruit kijk), ik krijg het volgende cijfers:
>>> 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
Dus de lelijkste optie xrange(len(xs)-1,-1,-1)is de snelste.
Antwoord 22
Als u het niet erg vindt dat de index negatief is, kunt u doen:
>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
... print(~i, a[~i]))
-1 baz
-2 bar
-3 foo
Antwoord 23
De andere antwoorden zijn goed, maar als u dat wilt doen
Lijst Begrijpingsstijl
collection = ['a','b','c']
[item for item in reversed( collection ) ]
Antwoord 24
Een eenvoudige manier:
n = int(input())
arr = list(map(int, input().split()))
for i in reversed(range(0, n)):
print("%d %d" %(i, arr[i]))
Antwoord 25
input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
print(input_list[i])
ik denk dat dit ook een eenvoudige manier is om het te doen… lees vanaf het einde en blijf verlagen tot de lengte van de lijst, aangezien we nooit de “end” index uitvoeren en daarom ook -1 toegevoegd
Antwoord 26
u kunt een generator gebruiken:
li = [1,2,3,4,5,6]
len_li = len(li)
gen = (len_li-1-i for i in range(len_li))
eindelijk:
for i in gen:
print(li[i])
ik hoop dat dit je helpt.