comment faire une boucle vers le bas dans la liste python (compte à rebours)

comment faire une boucle vers le bas dans la liste python?

par exemple

boucle:

L = [1,2,3]
for item in L
    print item #-->1,2,3

boucle vers le bas:

L = [1,2,3]
for ???
    print item #-->3,2,1

merci

OriginalL'auteur nguyên | 2011-07-08

  1. 6

    Une autre solution:

    for item in L[::-1]:
    print item
    Notez que cela va créer temporairement une copie inverse de la séquence, alors que reversed() ne copie si nécessaire.
    +3 pour la création d'une copie? Désolé, mais cela mérite un -3
    L[::-1]: courir plus vite que reversed(L)
    Sur mon ordinateur, reversed(L) est plus rapide que L[::-1].

    OriginalL'auteur Jacob

  2. 16

    Piles incluses.

    for i in reversed([1, 2, 3]):
    print i

    Découpage de la liste (ls[::-1]) est idéal pour faire une copie inverse, mais sur ma machine c'est plus lent pour l'itération, même si la liste est déjà en mémoire:

    >>> def sliceit(x):
...     l = range(x)
...     for i in l[::-1]:
...         i
...       
>>> def reverseit(x):
...     l = range(x)
...     for i in reversed(l):
...         i
...         
>>> %timeit sliceit(100)
100000 loops, best of 3: 4.04 µs per loop
>>> %timeit reverseit(100)
100000 loops, best of 3: 3.79 µs per loop
>>> %timeit sliceit(1000)
10000 loops, best of 3: 34.9 µs per loop
>>> %timeit reverseit(1000)
10000 loops, best of 3: 32.5 µs per loop
>>> %timeit sliceit(10000)
1000 loops, best of 3: 364 µs per loop
>>> %timeit reverseit(10000)
1000 loops, best of 3: 331 µs per loop

    Comme c'est souvent le cas dans ce genre de cas, la différence est assez négligeable. Il peut être différent pour les différentes versions de Python (j'ai utilisé de Python 2.7 pour le test ci-dessus). Le réel avantage de l'utilisation de reversed est la lisibilité -- il serait préférable, dans la plupart des cas, même si cela coûte quelques microsecondes.

    OriginalL'auteur senderle

  3. 7

    Inverser la séquence.

    L = [1,2,3]
for item in reversed(L)
    print item #-->3,2,1

    OriginalL'auteur Ignacio Vazquez-Abrams

  4. 3

    Je sais que ce fil est maintenant ans, mais un commentaire sous la accepté de répondre contient l'affirmation selon laquelle l'utilisation [::-1] est plus rapide que l'utilisation reversed(). Ceci est vrai uniquement si votre liste est explicitement mis en mémoire, ce qui est pas nécessaire lorsque l'on fait un compte à rebours. Sinon, il est plus lent:

    >>> timeit.Timer(stmt="range(1,1000)[::-1]").timeit()
10.801303316066111
>>> timeit.Timer(stmt="list(reversed(xrange(1,1000)))").timeit()
9.484562358901144

    ...et [::-1] utilise plus d'espace que reversed.

    Sur mon ordinateur reversed est plus rapide, même pour les listes déjà en mémoire. (Voir les horaires sur mon édité réponse.)

    OriginalL'auteur rhombidodecahedron