Le meilleur moyen de créer une liste «inversée» en Python?

En Python, quel est le meilleur moyen de créer une nouvelle liste dont les éléments sont les mêmes que ceux d'une autre liste, mais dans l'ordre inverse? (Je ne veux pas modifier la liste existante en place.)

Voici une solution qui m'est venue à l'esprit:

new_list = list(reversed(old_list))

Il est également possible de dupliquer old_listpuis d'inverser le duplicata en place:

new_list = list(old_list) # or `new_list = old_list[:]`
new_list.reverse()

Y a-t-il une meilleure option que j'ai négligée? Sinon, y a-t-il une raison impérieuse (comme l'efficacité) d'utiliser l'une des approches ci-dessus plutôt que l'autre?

newlist = oldlist[::-1]

Le [::-1]tranchage (que ma femme Anna aime appeler "le smiley martien" ;-) signifie: trancher toute la séquence, avec un pas de -1, c'est-à-dire à l'envers. Cela fonctionne pour toutes les séquences.

Notez que ceci ( et les alternatives que vous avez mentionnées) équivaut à une "copie superficielle", c'est-à-dire: si les éléments sont mutables et que vous appelez des mutateurs sur eux, les mutations des éléments contenus dans la liste d'origine sont également dans les éléments de la liste inversée, et vice versa. Si vous devez éviter cela, un copy.deepcopy(bien que toujours une opération potentiellement coûteuse), suivi dans ce cas par un .reverse, est la seule bonne option.

Maintenant allons timeit. Indice: celui d' Alex [::-1]est le plus rapide :)

$ p -m timeit "ol = [1, 2, 3]; nl = list(reversed(ol))"
100000 loops, best of 3: 2.34 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = list(ol); nl.reverse();"
1000000 loops, best of 3: 0.686 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = ol[::-1];"
1000000 loops, best of 3: 0.569 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = [i for i in reversed(ol)];"
1000000 loops, best of 3: 1.48 usec per loop


$ p -m timeit "ol = [1, 2, 3]*1000; nl = list(reversed(ol))"
10000 loops, best of 3: 44.7 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = list(ol); nl.reverse();"
10000 loops, best of 3: 27.2 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = ol[::-1];"
10000 loops, best of 3: 24.3 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = [i for i in reversed(ol)];"
10000 loops, best of 3: 155 usec per loop

Mise à jour: Ajout de la méthode de compilation de liste suggérée par inspectorG4dget. Je vais laisser les résultats parler d'eux-mêmes.

Ajustements

Cela vaut la peine de fournir une référence / un ajustement de base pour les calculs de timeit par sdolan qui montrent les performances de `` inversé '' sans la list()conversion souvent inutile . Cette list()opération ajoute 26 usecs supplémentaires au runtime et n'est nécessaire que dans le cas où un itérateur est inacceptable.

Résultats:

reversed(lst) -- 11.2 usecs

list(reversed(lst)) -- 37.1 usecs

lst[::-1] -- 23.6 usecs

Calculs:

# I ran this set of 100000 and came up with 11.2, twice:
python -m timeit "ol = [1, 2, 3]*1000; nl = reversed(ol)"
100000 loops, best of 3: 11.2 usec per loop

# This shows the overhead of list()
python -m timeit "ol = [1, 2, 3]*1000; nl = list(reversed(ol))"
10000 loops, best of 3: 37.1 usec per loop

# This is the result for reverse via -1 step slices
python -m timeit "ol = [1, 2, 3]*1000;nl = ol[::-1]"
10000 loops, best of 3: 23.6 usec per loop

Conclusions:

La conclusion de ces tests est reversed()plus rapide que la tranche [::-1]de 12,4 usecs