C'est une question très simple, mais je n'ai pas semblé être capable de trouver une réponse satisfaisante.
Quel est le meilleur moyen, en Python, faire le dernier élément d'une liste devenue la première "poussant" le reste de la liste.
quelque chose qui fait: Je sais que je peux toujours jouer avec mais cela n'a pas l'air correct ... " pythoniques ", si vous pouvez < p> Merci d'avance. len , liste de la concaténation ...
4 Réponses :
La tranchée est un peu plus intelligente que celle-ci; Vous pouvez utiliser indices négatifs pour compter à partir de la fin: démonstration: Ceci fonctionne pour un Nombre arbitraire d'éléments à déplacer vers le front: Utilisation de la tranchée comme celui-ci est comparable à la vitesse à l'aide de mais gagne la main vers le bas si vous devez passer plus d'un élément: < Pré> xxx .insert () + .pop () (sur une courte liste):
Il crée toujours une nouvelle liste (trois listes réellement) où elle ne devrait pas en créer.
@delnan: Pourquoi ne devrait-il pas en créer?
Parce que cela n'a pas besoin de, et cela ajoute plusieurs travers de liste pour absolument aucune raison.
MEH ne doit pas nécessairement que ne soit pas nécessairement assimiler à ne devrait pas IMHO ... avec des listes plus petites, elle ne va évidemment pas exécuter la performance ... avec gigantesque, il pourrait un peu .. .
@delnan Cette opération ne peut pas être effectuée en moins que O (n) lors de l'utilisation de listes régulières.
@interjay Oui, j'ai mal compris le problème. Néanmoins, trois travers de liste (y compris les allocations) sont pires qu'un. Et je ne suis pas principalement préoccupé par la performance (une boucle C copiant un tableau de pyObject * s est rapide ), il semble que ce soit comme tuant des cafards avec des armes automatiques.
In [103]: a=[1,2,3,4]
In [104]: a.insert(0,a.pop(-1)) # pop(-1) removes the last element
# and use insert() to insert the popped
# element at 0th endex
In [105]: a
Out[105]: [4, 1, 2, 3]
Vous voudrez peut-être regarder DEQUE , qui sont optimisées ( Mémoire sage) Pour faire ce que vous demandez, si vous en faites beaucoup. puisque nous faisons Timeit pour comparer ...
J'ai utilisé dequoise quelques fois et je n'y pensais pas maintenant, car j'ai une liste stockée comme [1,2,3,4] qui doit être émise (sur une page Web, en fait) comme [4 , 1, 2, 3]. La mémoire n'est pas un problème ... Je suis plus intéressé par la vitesse. Je pensais que la convertissage d'une liste en une deque puis de le faire pivoter est plus de temps que la tranchage. Qu'en penses-tu? (Je n'ai aucune idée des performances deque)
@Borrajax j'ai ajouté des informations de performance. Deque est de manière significative plus rapide.
Arg ... J'ai peur dans ce cas particulier ce n'est pas une option car la rotation (1) ne renvoie pas la dentelle et tout ce processus est effectué dans un modèle pour générer HTML (il a donc besoin d'une doublure uniquement) Merci beaucoup pour l'indice, bien que
Si vous n'allez pas effectuer la rotation une fois, l'instanciation de la drique a un peu de surcharge qui le rend plus lent que de trancher la liste. J'allais suggérer de faire une fonction qui retourne une dent et l'utilise dans votre doublure, mais la performance-sage, on dirait que vous serez mieux servi par la liste de la liste, de toute façon.
@Borrajax Si vous avez juste besoin de Afficher la liste pivotée, pourquoi pas simplement utiliser une fonction pour cracher des articles donnés à un ordre arbitraire?
Si vous avez juste besoin de vider une liste d'accès arbitrairement accessible, comme vous l'avez mentionné dans le commentaire à @Kreativitea, la réinscription peut ne pas être nécessaire, et vous pouvez concevoir un générateur d'accès arbitraire à la place:
size = 10
l = range(size)
# use a generator expression to yield slices of the list according
# to your own order.
# note that no error checking is enforced, and that overlapping
# and invalid accessRanges will work, so depending on the usage
# you have for this function, you might want to add some
# sanity checks, like ensuring no overlap between accessRanges
# and that each item is accessed only once.
def ArbitraryListAccessor(listObj, accessRanges):
for ar in accessRanges:
for item in listObj[ar[0]:ar[1]]:
yield item
# to dump the access-ordered list generator as a real list, you need to
# iterate over it, for example, with a list comprehension:
[i for i in ArbitraryListAccessor(l, ((-1,None), (0,-1)))]
# [9, 0, 1, 2, 3, 4, 5, 6, 7, 8]