Cara efisien untuk memutar daftar dengan python

Apa cara paling efisien untuk memutar daftar dengan python? Saat ini saya punya sesuatu seperti ini:

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

Apakah ada cara yang lebih baik?

A collections.dequedioptimalkan untuk menarik dan mendorong kedua ujungnya. Mereka bahkan memiliki rotate()metode khusus .

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]

Bagaimana kalau hanya menggunakan pop(0)?

list.pop([i])

Hapus item pada posisi yang diberikan dalam daftar, dan kembalikan. Jika tidak ada indeks yang ditentukan, a.pop()hapus dan kembalikan item terakhir dalam daftar. (Tanda kurung siku di idalam tanda tangan metode menunjukkan bahwa parameter bersifat opsional, bukan Anda harus mengetik tanda kurung siku pada posisi itu. Anda akan sering melihat notasi ini di Referensi Pustaka Python.)

Numpy dapat melakukan ini menggunakan rollperintah:

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

Itu tergantung pada apa yang Anda inginkan terjadi ketika Anda melakukan ini:

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

Anda mungkin ingin mengubah:

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

untuk:

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

Cara paling sederhana yang bisa saya pikirkan:

a.append(a.pop(0))

Jika Anda hanya ingin mengulangi set elemen ini daripada membangun struktur data terpisah, pertimbangkan untuk menggunakan iterator untuk membuat ekspresi generator:

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

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

Ini juga tergantung pada apakah Anda ingin menggeser daftar di tempatnya (memutasikannya), atau jika Anda ingin fungsi mengembalikan daftar baru. Karena, menurut pengujian saya, sesuatu seperti ini setidaknya dua puluh kali lebih cepat daripada implementasi Anda yang menambahkan dua daftar:

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

Bahkan, bahkan menambahkan a l = l[:]ke atas itu untuk beroperasi pada salinan daftar yang disahkan masih dua kali lebih cepat.

Berbagai implementasi dengan sejumlah waktu di http://gist.github.com/288272

Hanya beberapa catatan tentang waktu:

Jika Anda memulai dengan daftar, l.append(l.pop(0))adalah metode tercepat yang dapat Anda gunakan. Ini dapat ditunjukkan dengan kompleksitas waktu saja:

• deque.rotate adalah O (k) (k = jumlah elemen)
• konversi daftar ke deque adalah O (n)
• list.append dan list.pop keduanya O (1)

Jadi, jika Anda memulai dengan dequeobjek, Anda bisa deque.rotate()dengan biaya O (k). Tetapi, jika titik awal adalah daftar, kompleksitas waktu penggunaan deque.rotate()adalah O (n). l.append(l.pop(0)lebih cepat di O (1).

Hanya demi ilustrasi, berikut adalah beberapa contoh waktu pada iterasi 1M:

Metode yang memerlukan konversi jenis:

• deque.rotatedengan objek deque: 0,12380790710449219 detik (tercepat)
• deque.rotatedengan konversi tipe: 6.853878974914551 detik
• np.rolldengan nparray: 6.0491721630096436 detik
• np.rolldengan konversi tipe: 27.558452129364014 detik

Daftar metode yang disebutkan di sini:

• l.append(l.pop(0)): 0,32483696937561035 detik (tercepat)
• " shiftInPlace": 4,819645881652832 detik
• ...

Kode waktu yang digunakan adalah di bawah ini.

collections.deque

Menunjukkan bahwa membuat deques dari daftar adalah 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

Jika Anda perlu membuat objek deque:

Iterasi 1M @ 6,853878974914551 detik

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)

Jika Anda sudah memiliki objek deque:

Iterasi 1M @ 0,12380790710449219 detik

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

Jika Anda perlu membuat nparrays

Iterasi 1M @ 27.558452129364014 detik

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

Jika Anda sudah memiliki nparray:

Iterasi 1M @ 6.0491721630096436 detik

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)

"Bergeser di tempat"

Tidak memerlukan konversi jenis

Iterasi 1M @ 4,819645881652832 detik

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

Tidak memerlukan konversi jenis

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

Saya juga tertarik dengan ini dan membandingkan beberapa solusi yang disarankan dengan perfplot (proyek kecil saya).

Ternyata itu

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

adalah jauh metode tercepat untuk pergeseran kecil n.

Untuk yang lebih besar n,

data[n:] + data[:n]

tidak buruk.

Pada dasarnya, perfplot melakukan pergeseran untuk meningkatkan array besar dan mengukur waktu. Inilah hasilnya:

shift = 1:

shift = 100:

Kode untuk mereproduksi plot:

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

Mungkin ringbuffer lebih cocok. Ini bukan daftar, meskipun kemungkinan itu bisa berperilaku cukup seperti daftar untuk tujuan Anda.

Masalahnya adalah bahwa efisiensi pergeseran pada daftar adalah O (n), yang menjadi signifikan untuk daftar yang cukup besar.

Bergeser di ringbuffer hanya memperbarui lokasi kepala yaitu O (1)

Untuk implementasi yang tidak berubah, Anda dapat menggunakan sesuatu seperti ini:

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)

Jika efisiensi adalah tujuan Anda, (siklus? Memori?) Anda mungkin lebih baik melihat modul array: http://docs.python.org/library/array.html

Array tidak memiliki overhead daftar.

Sejauh daftar murni pergi, apa yang Anda miliki adalah tentang sebaik yang bisa Anda harapkan untuk dilakukan.

Saya pikir Anda mencari ini:

a.insert(0, x)

Alternatif lain:

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

Saya menggunakan model biaya ini sebagai referensi:

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

Metode Anda mengiris daftar dan menggabungkan dua sub-daftar adalah operasi waktu linier. Saya sarankan menggunakan pop, yang merupakan operasi waktu-konstan, misalnya:

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

Saya tidak tahu apakah ini 'efisien', tetapi juga berfungsi:

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

EDIT: Halo lagi, saya baru saja menemukan masalah besar dengan solusi ini! Pertimbangkan kode berikut:

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

Metode shift_classlist () mengeksekusi kode yang sama dengan x.insert (0, x.pop ()) - solusi saya, otherlist adalah daftar indipendent dari kelas. Setelah meneruskan konten daftar lain ke daftar MyClass.classlist, memanggil shift_classlist () juga mengubah daftar daftar lain:

OUTPUT KONSOL:

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!

Saya menggunakan Python 2.7. Saya tidak tahu apakah itu bug, tapi saya pikir lebih mungkin saya salah mengerti sesuatu di sini.

Apakah ada di antara kalian yang tahu mengapa ini terjadi?

Metode berikut adalah O (n) pada tempatnya dengan memori bantu konstan:

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

Perhatikan bahwa dalam python, pendekatan ini sangat tidak efisien dibandingkan dengan yang lain karena tidak dapat mengambil keuntungan dari implementasi asli dari salah satu bagian.

Saya punya hal serupa. Misalnya, untuk beralih dua ...

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

Saya pikir Anda punya cara yang paling efisien

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

Apa gunanya? Seringkali, kita tidak benar-benar membutuhkan array yang sepenuhnya bergeser - kita hanya perlu mengakses beberapa elemen dalam array yang digeser.

Mendapatkan irisan Python adalah runtime O (k) di mana k adalah slice, jadi rotasi irisan adalah runtime N. Perintah rotasi deque juga O (k). Bisakah kita berbuat lebih baik?

Pertimbangkan sebuah array yang sangat besar (katakanlah, begitu besar itu akan lambat untuk mengirisnya). Solusi alternatif adalah meninggalkan array asli sendirian dan hanya menghitung indeks item yang akan ada dalam indeks yang diinginkan setelah perubahan jenis.

Mengakses elemen yang bergeser dengan demikian menjadi 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 

Fungsi berikut menyalin daftar yang dikirim ke templist, sehingga fungsi pop tidak mempengaruhi daftar asli:

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

Pengujian:

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)

Keluaran:

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 dalam Pemrograman Mutiara (Kolom 2) menjelaskan algoritma yang elegan dan efisien untuk memutar nvektor elemen- xkiri oleh iposisi:

Mari kita lihat masalah sebagai mentransformasikan array abke dalam array ba, tetapi mari kita juga berasumsi bahwa kita memiliki fungsi yang membalikkan elemen-elemen dalam bagian tertentu dari array. Dimulai dengan ab, kita membalikkan auntuk mendapatkan , membalikkan untuk mendapatkan , dan kemudian membalikkan semuanya untuk mendapatkan , yang tepatnya . Ini menghasilkan kode berikut untuk rotasi:arbbarbr(arbr)rba

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

Ini dapat diterjemahkan ke Python sebagai berikut:

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

Untuk daftar X = ['a', 'b', 'c', 'd', 'e', 'f']dan nilai pergeseran yang diinginkan shift kurang dari panjang daftar , kita dapat mendefinisikan fungsi list_shift()seperti di bawah ini

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

Contoh,

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

Misalnya diberikan

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

fungsi harus kembali [9, 7, 6, 3, 8]. Tiga rotasi dibuat:

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

Sebagai contoh lain, diberikan

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

fungsi harus kembali [0, 0, 0]

Diberikan

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

fungsi harus kembali [1, 2, 3, 4]

Saya sedang mencari solusi untuk masalah ini. Ini memecahkan tujuan dalam 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

untuk fungsi yang sama dengan pergeseran dalam bahasa lain:

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