Un moyen efficace de faire pivoter une liste en python

Quelle est la façon la plus efficace de faire pivoter une liste en python? En ce moment, j'ai quelque chose comme ça:

>>> def rotate(l, n):
...     return l[n:] + l[:n]
... 
>>> l = [1,2,3,4]
>>> rotate(l,1)
[2, 3, 4, 1]
>>> rotate(l,2)
[3, 4, 1, 2]
>>> rotate(l,0)
[1, 2, 3, 4]
>>> rotate(l,-1)
[4, 1, 2, 3]

Y a-t-il une meilleure façon?

A collections.dequeest optimisé pour tirer et pousser sur les deux extrémités. Ils ont même une rotate()méthode dédiée .

from collections import deque
items = deque([1, 2])
items.append(3)        # deque == [1, 2, 3]
items.rotate(1)        # The deque is now: [3, 1, 2]
items.rotate(-1)       # Returns deque to original state: [1, 2, 3]
item = items.popleft() # deque == [2, 3]

Qu'en est-il simplement d'utiliser pop(0)?

list.pop([i])

Retirez l'élément à la position donnée dans la liste et renvoyez-le. Si aucun index n'est spécifié, a.pop()supprime et renvoie le dernier élément de la liste. (Les crochets autour ide la signature de méthode indiquent que le paramètre est facultatif, pas que vous devez taper des crochets à cette position. Vous verrez cette notation fréquemment dans la référence de bibliothèque Python.)

Numpy peut le faire en utilisant la rollcommande:

>>> import numpy
>>> a=numpy.arange(1,10) #Generate some data
>>> numpy.roll(a,1)
array([9, 1, 2, 3, 4, 5, 6, 7, 8])
>>> numpy.roll(a,-1)
array([2, 3, 4, 5, 6, 7, 8, 9, 1])
>>> numpy.roll(a,5)
array([5, 6, 7, 8, 9, 1, 2, 3, 4])
>>> numpy.roll(a,9)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

Cela dépend de ce que vous voulez que vous ayez à faire:

>>> shift([1,2,3], 14)

Vous voudrez peut-être changer votre:

def shift(seq, n):
    return seq[n:]+seq[:n]

à:

def shift(seq, n):
    n = n % len(seq)
    return seq[n:] + seq[:n]

La façon la plus simple à laquelle je peux penser:

a.append(a.pop(0))

Si vous souhaitez simplement parcourir ces ensembles d'éléments plutôt que de construire une structure de données distincte, envisagez d'utiliser des itérateurs pour construire une expression de générateur:

def shift(l,n):
    return itertools.islice(itertools.cycle(l),n,n+len(l))

>>> list(shift([1,2,3],1))
[2, 3, 1]

Cela dépend également si vous souhaitez déplacer la liste en place (en la mutant) ou si la fonction doit renvoyer une nouvelle liste. Parce que, selon mes tests, quelque chose comme ça est au moins vingt fois plus rapide que votre implémentation qui ajoute deux listes:

def shiftInPlace(l, n):
    n = n % len(l)
    head = l[:n]
    l[:n] = []
    l.extend(head)
    return l

En fait, même ajouter un l = l[:]en haut de celui-ci pour fonctionner sur une copie de la liste transmise est toujours deux fois plus rapide.

Diverses implémentations avec un certain timing sur http://gist.github.com/288272

Juste quelques notes sur le timing:

Si vous commencez avec une liste, l.append(l.pop(0))c'est la méthode la plus rapide que vous pouvez utiliser. Cela peut être démontré avec la seule complexité du temps:

• deque.rotate est O (k) (k = nombre d'éléments)
• la conversion de la liste en deque est O (n)
• list.append et list.pop sont tous deux O (1)

Donc, si vous commencez avec des dequeobjets, vous pouvez le faire deque.rotate()au prix de O (k). Mais, si le point de départ est une liste, la complexité temporelle de l'utilisation deque.rotate()est O (n). l.append(l.pop(0)est plus rapide à O (1).

Juste à titre d'illustration, voici quelques exemples de timings sur les itérations 1M:

Méthodes qui nécessitent une conversion de type:

• deque.rotateavec objet deque: 0,12380790710449219 secondes (le plus rapide)
• deque.rotateavec conversion de type: 6,853878974914551 secondes
• np.rollavec nparray: 6.0491721630096436 secondes
• np.rollavec conversion de type: 27,558452129364014 secondes

Liste des méthodes mentionnées ici:

• l.append(l.pop(0)): 0,32483696937561035 secondes (le plus rapide)
• " shiftInPlace": 4,819645881652832 secondes
• ...

Le code temporel utilisé est ci-dessous.

collections.deque

Montrer que la création de deques à partir de listes est O (n):

from collections import deque
import big_o

def create_deque_from_list(l):
     return deque(l)

best, others = big_o.big_o(create_deque_from_list, lambda n: big_o.datagen.integers(n, -100, 100))
print best

# --> Linear: time = -2.6E-05 + 1.8E-08*n

Si vous devez créer des objets deque:

1M itérations @ 6,853878974914551 secondes

setup_deque_rotate_with_create_deque = """
from collections import deque
import random
l = [random.random() for i in range(1000)]
"""

test_deque_rotate_with_create_deque = """
dl = deque(l)
dl.rotate(-1)
"""
timeit.timeit(test_deque_rotate_with_create_deque, setup_deque_rotate_with_create_deque)

Si vous avez déjà des objets deque:

1M itérations @ 0,12380790710449219 secondes

setup_deque_rotate_alone = """
from collections import deque
import random
l = [random.random() for i in range(1000)]
dl = deque(l)
"""

test_deque_rotate_alone= """
dl.rotate(-1)
"""
timeit.timeit(test_deque_rotate_alone, setup_deque_rotate_alone)

np.roll

Si vous devez créer des nparrays

1M itérations @ 27,558452129364014 secondes

setup_np_roll_with_create_npa = """
import numpy as np
import random
l = [random.random() for i in range(1000)]
"""

test_np_roll_with_create_npa = """
np.roll(l,-1) # implicit conversion of l to np.nparray
"""

Si vous avez déjà des nparrays:

1M itérations @ 6.0491721630096436 secondes

setup_np_roll_alone = """
import numpy as np
import random
l = [random.random() for i in range(1000)]
npa = np.array(l)
"""

test_roll_alone = """
np.roll(npa,-1)
"""
timeit.timeit(test_roll_alone, setup_np_roll_alone)

"Déplacer en place"

Ne nécessite aucune conversion de type

1M itérations @ 4.819645881652832 secondes

setup_shift_in_place="""
import random
l = [random.random() for i in range(1000)]
def shiftInPlace(l, n):
    n = n % len(l)
    head = l[:n]
    l[:n] = []
    l.extend(head)
    return l
"""

test_shift_in_place="""
shiftInPlace(l,-1)
"""

timeit.timeit(test_shift_in_place, setup_shift_in_place)

l.append (l.pop (0))

Ne nécessite aucune conversion de type

1M itérations @ 0,32483696937561035

setup_append_pop="""
import random
l = [random.random() for i in range(1000)]
"""

test_append_pop="""
l.append(l.pop(0))
"""
timeit.timeit(test_append_pop, setup_append_pop)

Je me suis également intéressé à cela et j'ai comparé certaines des solutions suggérées avec perfplot (un petit projet à moi).

Il se trouve que

for _ in range(n):
    data.append(data.pop(0))

est de loin la méthode la plus rapide pour les petites équipes n.

Pour les plus grands n,

data[n:] + data[:n]

n'est pas mauvais.

Essentiellement, perfplot effectue le changement pour augmenter les grands tableaux et mesure le temps. Voici les résultats:

shift = 1:

shift = 100:

Code pour reproduire l'intrigue:

import numpy
import perfplot
import collections


shift = 100


def list_append(data):
    return data[shift:] + data[:shift]


def shift_concatenate(data):
    return numpy.concatenate([data[shift:], data[:shift]])


def roll(data):
    return numpy.roll(data, -shift)


def collections_deque(data):
    items = collections.deque(data)
    items.rotate(-shift)
    return items


def pop_append(data):
    for _ in range(shift):
        data.append(data.pop(0))
    return data


perfplot.save(
    "shift100.png",
    setup=lambda n: numpy.random.rand(n).tolist(),
    kernels=[list_append, roll, shift_concatenate, collections_deque, pop_append],
    n_range=[2 ** k for k in range(7, 20)],
    logx=True,
    logy=True,
    xlabel="len(data)",
)

Peut-être qu'un ringbuffer est plus approprié. Ce n'est pas une liste, bien qu'il soit probable qu'elle puisse se comporter assez comme une liste pour vos besoins.

Le problème est que l'efficacité d'un décalage sur une liste est O (n), ce qui devient significatif pour des listes suffisamment grandes.

Le passage dans un ringbuffer met simplement à jour l'emplacement de la tête qui est O (1)

Pour une implémentation immuable, vous pouvez utiliser quelque chose comme ceci:

def shift(seq, n):
    shifted_seq = []
    for i in range(len(seq)):
        shifted_seq.append(seq[(i-n) % len(seq)])
    return shifted_seq

print shift([1, 2, 3, 4], 1)

Si l'efficacité est votre objectif, (cycles? Mémoire?), Vous feriez peut-être mieux de regarder le module de tableau: http://docs.python.org/library/array.html

Les tableaux n'ont pas la surcharge des listes.

En ce qui concerne les listes pures, ce que vous avez est aussi bon que vous pouvez l'espérer.

Je pense que vous cherchez ceci:

a.insert(0, x)

Une autre alternative:

def move(arr, n):
    return [arr[(idx-n) % len(arr)] for idx,_ in enumerate(arr)]

Je prends ce modèle de coût comme référence:

http://scripts.mit.edu/~6.006/fall07/wiki/index.php?title=Python_Cost_Model

Votre méthode de découpage de la liste et de concaténation de deux sous-listes est une opération à temps linéaire. Je suggère d'utiliser pop, qui est une opération à temps constant, par exemple:

def shift(list, n):
    for i in range(n)
        temp = list.pop()
        list.insert(0, temp)

Je ne sais pas si c'est «efficace», mais ça marche aussi:

x = [1,2,3,4]
x.insert(0,x.pop())

EDIT: Bonjour encore une fois, je viens de trouver un gros problème avec cette solution! Considérez le code suivant:

class MyClass():
    def __init__(self):
        self.classlist = []

    def shift_classlist(self): # right-shift-operation
        self.classlist.insert(0, self.classlist.pop())

if __name__ == '__main__':
    otherlist = [1,2,3]
    x = MyClass()

    # this is where kind of a magic link is created...
    x.classlist = otherlist

    for ii in xrange(2): # just to do it 2 times
        print '\n\n\nbefore shift:'
        print '     x.classlist =', x.classlist
        print '     otherlist =', otherlist
        x.shift_classlist() 
        print 'after shift:'
        print '     x.classlist =', x.classlist
        print '     otherlist =', otherlist, '<-- SHOULD NOT HAVE BIN CHANGED!'

La méthode shift_classlist () exécute le même code que ma solution x.insert (0, x.pop ()) - otherlist est une liste indépendante de la classe. Après avoir transmis le contenu de l'autre liste à la liste MyClass.classlist, l'appel de shift_classlist () modifie également l'autre liste:

SORTIE CONSOLE:

before shift:
     x.classlist = [1, 2, 3]
     otherlist = [1, 2, 3]
after shift:
     x.classlist = [3, 1, 2]
     otherlist = [3, 1, 2] <-- SHOULD NOT HAVE BIN CHANGED!



before shift:
     x.classlist = [3, 1, 2]
     otherlist = [3, 1, 2]
after shift:
     x.classlist = [2, 3, 1]
     otherlist = [2, 3, 1] <-- SHOULD NOT HAVE BIN CHANGED!

J'utilise Python 2.7. Je ne sais pas si c'est un bug, mais je pense qu'il est plus probable que j'ai mal compris quelque chose ici.

Est-ce que quelqu'un d'entre vous sait pourquoi cela se produit?

La méthode suivante est O (n) en place avec une mémoire auxiliaire constante:

def rotate(arr, shift):
  pivot = shift % len(arr)
  dst = 0
  src = pivot
  while (dst != src):
    arr[dst], arr[src] = arr[src], arr[dst]
    dst += 1
    src += 1
    if src == len(arr):
      src = pivot
    elif dst == pivot:
      pivot = src

Notez qu'en python, cette approche est horriblement inefficace par rapport aux autres car elle ne peut tirer parti des implémentations natives d'aucune des pièces.

J'ai une chose similaire. Par exemple, pour décaler de deux ...

def Shift(*args):
    return args[len(args)-2:]+args[:len(args)-2]

Je pense que vous avez le moyen le plus efficace

def shift(l,n):
    n = n % len(l)  
    return l[-U:] + l[:-U]

Quel est le cas d'utilisation? Souvent, nous n'avons pas réellement besoin d'un tableau entièrement décalé - nous avons juste besoin d'accéder à une poignée d'éléments dans le tableau décalé.

L'obtention de tranches Python est exécutée O (k) où k est la tranche, donc une rotation en tranches est exécutée N. La commande deque rotation est également O (k). Pouvons-nous faire mieux?

Considérons un tableau qui est extrêmement grand (disons, si grand qu'il serait lent à calculer pour le découper). Une solution alternative serait de laisser le tableau d'origine seul et de simplement calculer l'indice de l'élément qui aurait existé dans notre indice souhaité après un changement quelconque.

Accéder à un élément décalé devient ainsi O (1).

def get_shifted_element(original_list, shift_to_left, index_in_shifted):
    # back calculate the original index by reversing the left shift
    idx_original = (index_in_shifted + shift_to_left) % len(original_list)
    return original_list[idx_original]

my_list = [1, 2, 3, 4, 5]

print get_shifted_element(my_list, 1, 2) ----> outputs 4

print get_shifted_element(my_list, -2, 3) -----> outputs 2 

La fonction suivante copie la liste envoyée à un templiste, afin que la fonction pop n'affecte pas la liste d'origine:

def shift(lst, n, toreverse=False):
    templist = []
    for i in lst: templist.append(i)
    if toreverse:
        for i in range(n):  templist = [templist.pop()]+templist
    else:
        for i in range(n):  templist = templist+[templist.pop(0)]
    return templist

Essai:

lst = [1,2,3,4,5]
print("lst=", lst)
print("shift by 1:", shift(lst,1))
print("lst=", lst)
print("shift by 7:", shift(lst,7))
print("lst=", lst)
print("shift by 1 reverse:", shift(lst,1, True))
print("lst=", lst)
print("shift by 7 reverse:", shift(lst,7, True))
print("lst=", lst)

Production:

lst= [1, 2, 3, 4, 5]
shift by 1: [2, 3, 4, 5, 1]
lst= [1, 2, 3, 4, 5]
shift by 7: [3, 4, 5, 1, 2]
lst= [1, 2, 3, 4, 5]
shift by 1 reverse: [5, 1, 2, 3, 4]
lst= [1, 2, 3, 4, 5]
shift by 7 reverse: [4, 5, 1, 2, 3]
lst= [1, 2, 3, 4, 5]

Jon Bentley dans Programming Pearls (Colonne 2) décrit un algorithme élégant et efficace pour faire tourner un nvecteur -élément xlaissé par des ipositions:

Considérons le problème comme transformant le tableau aben tableau ba, mais supposons également que nous avons une fonction qui inverse les éléments dans une partie spécifiée du tableau. En commençant par ab, nous inversons apour obtenir , inversons pour obtenir , puis inversons le tout pour obtenir , ce qui est exactement . Il en résulte le code de rotation suivant:arbbarbr(arbr)rba

reverse(0, i-1)
reverse(i, n-1)
reverse(0, n-1)

Cela peut être traduit en Python comme suit:

def rotate(x, i):
    i %= len(x)
    x[:i] = reversed(x[:i])
    x[i:] = reversed(x[i:])
    x[:] = reversed(x)
    return x

Démo:

>>> def rotate(x, i):
...     i %= len(x)
...     x[:i] = reversed(x[:i])
...     x[i:] = reversed(x[i:])
...     x[:] = reversed(x)
...     return x
... 
>>> rotate(list('abcdefgh'), 1)
['b', 'c', 'd', 'e', 'f', 'g', 'h', 'a']
>>> rotate(list('abcdefgh'), 3)
['d', 'e', 'f', 'g', 'h', 'a', 'b', 'c']
>>> rotate(list('abcdefgh'), 8)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> rotate(list('abcdefgh'), 9)
['b', 'c', 'd', 'e', 'f', 'g', 'h', 'a']

Pour une liste X = ['a', 'b', 'c', 'd', 'e', 'f']et une valeur de décalage souhaitée shift inférieure à la longueur de la liste , nous pouvons définir la fonction list_shift()comme ci-dessous

def list_shift(my_list, shift):
    assert shift < len(my_list)
    return my_list[shift:] + my_list[:shift]

Exemples,

list_shift(X,1)retourne ['b', 'c', 'd', 'e', 'f', 'a'] list_shift(X,3)retourne['d', 'e', 'f', 'a', 'b', 'c']

def solution(A, K):
    if len(A) == 0:
        return A

    K = K % len(A)

    return A[-K:] + A[:-K]

# use case
A = [1, 2, 3, 4, 5, 6]
K = 3
print(solution(A, K))

Par exemple, étant donné

A = [3, 8, 9, 7, 6]
K = 3

la fonction devrait revenir [9, 7, 6, 3, 8]. Trois rotations ont été effectuées:

[3, 8, 9, 7, 6] -> [6, 3, 8, 9, 7]
[6, 3, 8, 9, 7] -> [7, 6, 3, 8, 9]
[7, 6, 3, 8, 9] -> [9, 7, 6, 3, 8]

Pour un autre exemple, étant donné

A = [0, 0, 0]
K = 1

la fonction devrait retourner [0, 0, 0]

Donné

A = [1, 2, 3, 4]
K = 4

la fonction devrait retourner [1, 2, 3, 4]

Je cherchais une solution en place à ce problème. Cela résout le but de O (k).

def solution(self, list, k):
    r=len(list)-1
    i = 0
    while i<k:
        temp = list[0]
        list[0:r] = list[1:r+1]
        list[r] = temp
        i+=1
    return list

pour des fonctionnalités similaires à celles des changements dans d'autres langues:

def shift(l):
    x = l[0]
    del(l[0])
    return x