Modo efficiente per ruotare un elenco in Python

Qual è il modo più efficiente per ruotare un elenco in Python? In questo momento ho qualcosa del genere:

>>> 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]

C'è un modo migliore?

A collections.dequeè ottimizzato per tirare e spingere su entrambe le estremità. Hanno anche un rotate()metodo dedicato .

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]

Che ne dici di usare solo pop(0)?

list.pop([i])

Rimuovere l'elemento nella posizione specificata nell'elenco e restituirlo. Se non viene specificato alcun indice, a.pop()rimuove e restituisce l'ultimo elemento nell'elenco. (Le parentesi quadre intorno alla ifirma del metodo indicano che il parametro è facoltativo, non che dovresti digitare parentesi quadre in quella posizione. Vedrai questa notazione frequentemente nel Python Library Reference.)

Numpy può farlo usando il rollcomando:

>>> 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])

Dipende da cosa vuoi che accada quando fai questo:

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

Potresti voler cambiare il tuo:

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

per:

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

Il modo più semplice che mi viene in mente:

a.append(a.pop(0))

Se vuoi solo iterare su questi insiemi di elementi piuttosto che costruire una struttura di dati separata, considera l'utilizzo di iteratori per costruire un'espressione del generatore:

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

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

Ciò dipende anche se si desidera spostare l'elenco in posizione (mutandolo) o se si desidera che la funzione restituisca un nuovo elenco. Perché, secondo i miei test, qualcosa del genere è almeno venti volte più veloce della tua implementazione che aggiunge due elenchi:

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

In effetti, anche aggiungendo a l = l[:] in cima a quello per operare su una copia dell'elenco trasmesso è ancora due volte più veloce.

Varie implementazioni con alcuni tempi su http://gist.github.com/288272

Solo alcune note sui tempi:

Se stai iniziando con un elenco, l.append(l.pop(0))è il metodo più veloce che puoi utilizzare. Questo può essere mostrato con la sola complessità temporale:

• deque.rotate è O (k) (k = numero di elementi)
• la conversione da lista a deque è O (n)
• list.append e list.pop sono entrambi O (1)

Quindi, se stai iniziando con dequeoggetti, puoi deque.rotate()al costo di O (k). Ma, se il punto di partenza è un elenco, la complessità temporale dell'uso deque.rotate()è O (n). l.append(l.pop(0)è più veloce in O (1).

Solo a scopo illustrativo, ecco alcuni esempi di temporizzazioni su iterazioni 1M:

Metodi che richiedono la conversione del tipo:

• deque.rotatecon oggetto deque: 0,12380790710449219 secondi (il più veloce)
• deque.rotatecon conversione del tipo: 6,853878974914551 secondi
• np.rollcon nparray: 6.0491721630096436 secondi
• np.rollcon conversione del tipo: 27.558452129364014 secondi

Elenco dei metodi menzionati qui:

• l.append(l.pop(0)): 0,32483696937561035 secondi (il più veloce)
• "shiftInPlace ": 4.819645881652832 secondi
• ...

Il codice temporale utilizzato è di seguito.

collections.deque

Mostrando che la creazione di deques dagli elenchi è 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

Se è necessario creare oggetti deque:

1M iterazioni @ 6,853878974914551 secondi

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)

Se hai già oggetti deque:

Iterazioni 1M a 0,12380790710449219 secondi

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

Se è necessario creare nparray

1M iterazioni @ 27.558452129364014 secondi

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
"""

Se hai già nparray:

1M iterazioni @ 6.0491721630096436 secondi

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)

"Spostamento sul posto"

Non richiede conversione di tipo

Iterazioni 1M @ 4.819645881652832 secondi

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))

Non richiede conversione di tipo

1M iterazioni @ 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)

Mi sono anche interessato a questo e ho confrontato alcune delle soluzioni suggerite con perfplot (un mio piccolo progetto).

Si scopre che

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

è di gran lunga il metodo più veloce per i piccoli turnin .

Per più grandi n,

data[n:] + data[:n]

non è male.

In sostanza, perfplot esegue il turno per aumentare le matrici di grandi dimensioni e misura il tempo. Ecco i risultati:

shift = 1:

shift = 100:

Codice per riprodurre la trama:

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)",
)

Forse un ringbuffer è più adatto. Non è un elenco, anche se è probabile che possa comportarsi abbastanza come un elenco per i tuoi scopi.

Il problema è che l'efficienza di uno spostamento su un elenco è O (n), che diventa significativo per elenchi abbastanza grandi.

Spostare in un ringbuffer è semplicemente aggiornare la posizione della testa che è O (1)

Per un'implementazione immutabile, potresti usare qualcosa del genere:

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)

Se l'efficienza è il tuo obiettivo, (cicli? Memoria?) Potresti essere meglio guardando il modulo array: http://docs.python.org/library/array.html

Le matrici non hanno il sovraccarico delle liste.

Per quanto riguarda gli elenchi puri, quello che hai è buono come puoi sperare di fare.

Penso che tu stia cercando questo:

a.insert(0, x)

Un'altra alternativa:

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

Prendo questo modello di costo come riferimento:

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

Il metodo utilizzato per dividere l'elenco e concatenare due elenchi secondari sono operazioni a tempo lineare. Suggerirei di usare pop, che è un'operazione a tempo costante, ad esempio:

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

Non so se sia "efficiente", ma funziona anche:

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

EDIT: Ciao di nuovo, ho appena trovato un grosso problema con questa soluzione! Considera il seguente codice:

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!'

Il metodo shift_classlist () esegue lo stesso codice di my x.insert (0, x.pop ()) - soluzione, otherlist è un elenco indipendente dalla classe. Dopo aver passato il contenuto di otherlist all'elenco MyClass.classlist, la chiamata a shift_classlist () modifica anche l'elenco di otherlist:

USCITA DELLA CONSOLLE:

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!

Uso Python 2.7. Non so se sia un bug, ma penso sia più probabile che abbia capito male qualcosa qui.

Qualcuno di voi sa perché questo accade?

Il seguente metodo è O (n) in atto con memoria ausiliaria costante:

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

Nota che in Python questo approccio è orribilmente inefficiente rispetto ad altri in quanto non può sfruttare le implementazioni native di nessuno dei pezzi.

Ho una cosa simile. Ad esempio, per spostare di due ...

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

Penso che tu abbia il modo più efficiente

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

Qual è il caso d'uso? Spesso, in realtà non abbiamo bisogno di un array completamente spostato, dobbiamo solo accedere a una manciata di elementi nell'array spostato.

Ottenere sezioni Python è runtime O (k) dove k è la sezione, quindi una rotazione suddivisa è runtime N. Anche il comando di rotazione deque è O (k). Possiamo fare di meglio?

Considera un array estremamente grande (diciamo, così grande da computazionalmente lento da dividerlo). Una soluzione alternativa sarebbe quella di lasciare da solo l'array originale e semplicemente calcolare l'indice dell'articolo che sarebbe esistito nel nostro indice desiderato dopo uno spostamento di qualche tipo.

L'accesso a un elemento spostato diventa quindi 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 funzione seguente copia l'elenco inviato in un elenco temp, in modo che la funzione pop non influisca sull'elenco originale:

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

test:

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)

Produzione:

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 in Programming Pearls (Colonna 2) descrive un algoritmo elegante ed efficiente per ruotare un nvettore di elementi xlasciato dalle iposizioni:

Vediamo il problema come trasformazione dell'array abnell'array ba, ma supponiamo anche che abbiamo una funzione che inverte gli elementi in una porzione specifica dell'array. A partire da ab, invertiamo aper ottenere , invertiamo per ottenere , quindi invertiamo tutto per ottenere , che è esattamente . Ciò comporta il seguente codice per la rotazione:arbbarbr(arbr)rba

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

Questo può essere tradotto in Python come segue:

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

demo:

>>> 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']

Per un elenco X = ['a', 'b', 'c', 'd', 'e', 'f']e un valore di spostamento desiderato shift inferiore alla lunghezza dell'elenco , possiamo definire la funzione list_shift()come di seguito

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

Esempi,

list_shift(X,1)ritorni ['b', 'c', 'd', 'e', 'f', 'a'] list_shift(X,3)ritorni['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))

Ad esempio, dato

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

la funzione dovrebbe tornare [9, 7, 6, 3, 8]. Sono state fatte tre rotazioni:

[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]

Per un altro esempio, dato

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

la funzione dovrebbe tornare [0, 0, 0]

Dato

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

la funzione dovrebbe tornare [1, 2, 3, 4]

Stavo cercando una soluzione a questo problema. Questo risolve lo scopo in 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

per funzionalità simili a quelle del turno in altre lingue:

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