Pythonでリストを回転させる効率的な方法

Pythonでリストを回転させる最も効率的な方法は何ですか？現在、私はこのようなものを持っています：

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

もっと良い方法はありますか？

A collections.dequeは、両端を引っ張ったり押したりするように最適化されています。彼らは専用のrotate()方法さえ持っています。

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]

ただ使うのはpop(0)どうですか？

list.pop([i])

リスト内の指定された位置にあるアイテムを削除して返します。インデックスが指定されていない場合a.pop()、リストの最後のアイテムを削除して返します。（iメソッドシグネチャ内の角かっこは、パラメーターがオプションであることを示しています。その位置に角かっこを入力する必要はありません。この表記は、Pythonライブラリリファレンスに頻繁に表示されます。）

Numpyはroll次のコマンドを使用してこれを行うことができます：

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

これは、これを実行したときに何が起こりたいかによって異なります。

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

あなたはあなたを変えたいかもしれません：

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

に：

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

私が考えることができる最も簡単な方法：

a.append(a.pop(0))

個別のデータ構造を構築するのではなく、これらの要素のセットを反復処理するだけの場合は、反復子を使用してジェネレータ式を作成することを検討してください。

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

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

これは、リストを所定の位置にシフトする（変更する）か、または関数が新しいリストを返すかどうかにも依存します。私のテストによると、次のようなものは、2つのリストを追加する実装よりも少なくとも20倍高速です。

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

実際、l = l[:]渡されたリストのコピーを操作するためにその先頭にa を追加しても、2倍の速度です。

http://gist.github.com/288272のいくつかのタイミングでのさまざまな実装

タイミングに関する注意事項：

あなたがリストから始めているなら、l.append(l.pop(0))あなたが使うことができる最も速い方法です。これは、時間の複雑さだけで示すことができます。

• deque.rotateはO（k）です（k =要素の数）
• デキュー変換のリストはO（n）です
• list.appendとlist.popは両方ともO（1）です

したがって、dequeオブジェクトから始める場合はdeque.rotate()、O（k）を犠牲にしてできます。ただし、開始点がリストの場合、使用の時間の複雑さdeque.rotate()はO（n）です。l.append(l.pop(0)O（1）の方が高速です。

説明のために、1M反復のサンプルタイミングをいくつか次に示します。

型変換が必要なメソッド：

• deque.rotatedequeオブジェクトあり：0.12380790710449219秒（最速）
• deque.rotate型変換あり：6.853878974914551秒
• np.rollnparrayあり：6.0491721630096436秒
• np.roll型変換あり：27.558452129364014秒

ここに記載されているメソッドの一覧：

• l.append(l.pop(0))：0.32483696937561035秒（最速）
• " shiftInPlace"：4.819645881652832秒
• ...

使用するタイミングコードは以下のとおりです。

collections.deque

リストからの両端キューの作成が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

dequeオブジェクトを作成する必要がある場合：

1M反復@ 6.853878974914551秒

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)

dequeオブジェクトが既にある場合：

100万回の反復@ 0.12380790710449219秒

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

nparrayを作成する必要がある場合

1M反復@ 27.558452129364014秒

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

すでにnparrayがある場合：

1M反復@ 6.0491721630096436秒

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)

「所定の位置にシフト」

型変換は必要ありません

100万反復@ 4.819645881652832秒

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

型変換は必要ありません

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)

私はこれにも興味を持ち、提案されたソリューションのいくつかをperfplot（私の小さなプロジェクト）と比較しました。

それが判明

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

あるはるかに小さなシフトのための最速の方法n。

より大きいn場合、

data[n:] + data[:n]

悪くないです。

基本的に、perfplotは増加する大規模な配列のシフトを実行し、時間を測定します。結果は次のとおりです。

shift = 1：

shift = 100：

プロットを再現するコード：

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

おそらく、リングバッファの方が適しています。これはリストではありませんが、目的に応じてリストのように十分に動作する可能性があります。

問題は、リストのシフトの効率がO（n）であることです。これは、リストが十分に大きい場合に重要になります。

リングバッファをシフトすると、ヘッド位置がO（1）に更新されます

不変の実装では、次のようなものを使用できます。

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)

効率が目標の場合（サイクル？メモリ？）アレイモジュールを確認することをお勧めします：http : //docs.python.org/library/array.html

配列には、リストのオーバーヘッドはありません。

純粋なリストに関する限り、あなたが持っているものはあなたが望むことができるくらい良いです。

私はあなたがこれを探していると思います：

a.insert(0, x)

別の選択肢：

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

私はこのコストモデルを参考にしています：

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

リストをスライスして2つのサブリストを連結する方法は、線形時間操作です。私はpopを使用することをお勧めします。これは一定時間の操作です。

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

これが「効率的」かどうかはわかりませんが、うまくいきます。

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

編集：こんにちは、私はこのソリューションに大きな問題を見つけました！次のコードを検討してください。

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

shift_classlist（）メソッドは、私のx.insert（0、x.pop（））-solutionと同じコードを実行します。otherlistは、クラスに依存しないリストです。otherlistの内容をMyClass.classlistリストに渡した後、shift_classlist（）を呼び出すと、otherlistリストも変更されます。

コンソール出力：

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!

Python 2.7を使用しています。それがバグかどうかはわかりませんが、ここで何かを誤解している可能性が高いと思います。

これがなぜ起こるかあなたの誰かが知っていますか？

次のメソッドは、一定の補助メモリでO（n）を実行しています。

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

Pythonでは、この方法は他の部分に比べて非常に非効率的であり、どの部分のネイティブ実装も利用できないことに注意してください。

私にも似たようなものがあります。たとえば、2シフトすると...

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

私はあなたが最も効率的な方法を持っていると思います

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

ユースケースは何ですか？多くの場合、実際に完全にシフトされた配列は必要ありません-シフトされた配列内の少数の要素にアクセスする必要があるだけです。

Pythonスライスの取得はランタイムO（k）であり、kはスライスなので、スライスされた回転はランタイムNです。両端回転コマンドもO（k）です。もっと上手にできる？

非常に大きい配列を考えてみましょう（たとえば、非常に大きいと、スライスするのに計算速度が遅くなります）。別の解決策は、元の配列をそのままにして、何らかのシフト後に目的のインデックスに存在していた項目のインデックスを単純に計算することです。

したがって、シフトされた要素へのアクセスは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 

次の関数は送信されたリストをtemplistにコピーするため、pop関数は元のリストに影響しません。

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

テスト：

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)

出力：

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]

真珠のプログラミング（列2）のJon Bentleyは、位置によって左にn要素ベクトルを回転させるためのエレガントで効率的なアルゴリズムについて説明しています。xi

問題を配列を配列abに 変換するものと見なしbaますが、配列の指定された部分の要素を逆にする関数があるとします。から始めてab、a取得するために反転し、取得するために反転し、次に取得するため に全体を反転します。これは正確です。これにより、次の回転コードが生成されます。arbbarbr(arbr)rba

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

これは、次のようにPythonに変換できます。

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

デモ：

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

リストX = ['a', 'b', 'c', 'd', 'e', 'f']とshift リストの長さ未満の望ましいシフト値の場合、list_shift()次のように関数を定義できます。

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

例、

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

たとえば、

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

関数は返す必要があり[9, 7, 6, 3, 8]ます。3つのローテーションが行われました。

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

別の例として、

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

関数は返す必要があります [0, 0, 0]

与えられた

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

関数は返す必要があります [1, 2, 3, 4]

この問題の適切な解決策を探していました。これは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

他の言語のシフトと同様の機能：

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