在python中移动列表的有效方法

时间：2010-01-27 20:44:07

标签： python list

在python中移动列表的最有效方法是什么？ 现在我有这样的事情：

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

有更好的方法吗？

26 个答案:

答案 0 :(得分：238)

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]

答案 1 :(得分：85)

使用pop(0)怎么样？

  

list.pop([i])

     

删除列表中给定位置的项目，然后将其返回。如果   没有指定索引，a.pop()删除并返回最后一项   列表。 （方法签名中i周围的方括号   表示该参数是可选的，而不是您应该键入square   那个位置的括号。你会经常看到这种表示法   Python库参考。）

答案 2 :(得分：43)

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

答案 3 :(得分：33)

这取决于您执行此操作时想要发生的事情：

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

答案 4 :(得分：12)

如果您只想迭代这些元素集而不是构造单独的数据结构，请考虑使用迭代器来构造生成器表达式：

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

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

答案 5 :(得分：11)

这还取决于您是否要将列表移位（改变它），或者您希望函数返回新列表。因为根据我的测试，这样的事情至少比你添加两个列表的实现快20倍：

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

事实上，即使在传递列表副本的情况下在其顶部添加l = l[:]，仍然是原来的两倍。

在http://gist.github.com/288272

处有一些时间的各种实现

答案 6 :(得分：11)

我能想到的最简单的方式：

a.append(a.pop(0))

答案 7 :(得分：6)

关于时间安排的一些注意事项：

如果您从列表开始，l.append(l.pop(0))是您可以使用的最快方法。这可以单独显示时间复杂度：

  • deque.rotate O（k）（k =元素数量）
  • 列表转义为 O（n）
  • list.append和list.pop都是 O（1）

因此，如果您从deque个对象开始，则可以{O（k）为代价deque.rotate()。但是，如果起始点是列表，则使用deque.rotate()的时间复杂度为O（n）。在O（1）处l.append(l.pop(0)更快。

仅为了举例说明，以下是1M次迭代的一些示例时间：

需要类型转换的方法：

    带有deque对象的
  • deque.rotate： 0.12380790710449219秒（最快）
  • deque.rotate进行类型转换： 6.853878974914551秒
  • np.roll与nparray： 6.0491721630096436秒
  • np.roll进行类型转换： 27.558452129364014秒

列出这里提到的方法：

  • l.append(l.pop(0))： 0.32483696937561035秒（最快）
  • “shiftInPlace”： 4.819645881652832秒
  • ...

使用的时间码如下。

collections.deque

显示从列表创建deques是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

如果您需要创建双端队列对象：

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对象：

1M次迭代@ 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

如果你需要创建nparrays

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

如果你已经有nparrays：

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)

“转移到位”

不需要进行类型转换

1M次迭代@ 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)

答案 8 :(得分：4)

可能是一个更适合的缓冲环。它不是一个列表，尽管它可能像你的目的一样表现得足够。

问题是列表上的移位效率是O（n），这对于足够大的列表来说非常重要。

在一个环形缓冲区中移动只是更新头部位置，即O（1）

答案 9 :(得分：4)

我对此也很感兴趣，并将一些建议的解决方案与perfplot（属于我的一个小项目）进行了比较。

事实证明

for _ in range(n):
    data.append(data.pop(0))
到目前为止，

是最快的n换挡方法。

对于较大的n，

data[n:] + data[:n]

还不错。

本质上，perfplot执行移位以增加大型数组并测量时间。结果如下：

shift = 1：

enter image description here

shift = 100：

enter image description here

用于复制情节的代码：

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

答案 10 :(得分：4)

对于不可变的实现，您可以使用以下内容：

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)

答案 11 :(得分：3)

如果效率是你的目标，（周期？内存？）你可能最好看一下阵列模块：http://docs.python.org/library/array.html

数组没有列表的开销。

就纯粹的名单而言，你所拥有的就像你希望的一样好。

答案 12 :(得分：3)

我认为你正在寻找这个：

a.insert(0, x)

答案 13 :(得分：2)

另一种选择：

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

答案 14 :(得分：1)

我不知道这是否“有效”，但它也有效：

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（））相同的代码 - 解决方案，otherlist是一个独立于类的列表。将otherlist的内容传递给MyClass.classlist列表后，调用shift_classlist（）也会更改其他列表：

CONSOLE OUTPUT：

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。我不知道这是不是一个错误，但我认为我更有可能在这里错过了一些东西。

你们有谁知道为什么会这样吗？

答案 15 :(得分：1)

以下方法是具有常量辅助存储器的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中，与其他方法相比，这种方法效率极低，因为它无法利用任何部分的本机实现。

答案 16 :(得分：1)

我有类似的事情。例如，要换两个...... 

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

答案 17 :(得分：1)

我认为您获得了最有效的方式

$window.onscroll = function() {
    var status = document.body.scrollTop > document.body.scrollHeight;
    if(status) 
    console.log("working fine - tested");
}

答案 18 :(得分：1)

我将此成本模型作为参考：

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

切片列表和连接两个子列表的方法是线性时间操作。我建议使用pop，这是一个恒定时间操作，例如：

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

答案 19 :(得分：1)

对于列表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']

答案 20 :(得分：0)

用例是什么？通常，我们实际上并不需要完全移位的数组 - 我们只需要访问移位数组中的少数元素。

获取Python切片是运行时O（k），其中k是切片，因此切片旋转是运行时N. deque旋转命令也是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

答案 21 :(得分：0)

以下函数将发送列表复制到临时列表，这样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]

答案 22 :(得分：0)

Programming Pearls（第2列）中的乔恩·本特利（Jon Bentley）描述了一种优雅而有效的算法，用于旋转n个位置向左移动的x元素向量i：

  

让我们看问题为将数组ab转换为数组   ba，但我们还要假设我们有一个函数可以将   数组指定部分中的元素。从ab开始，我们   反转a得到arb，反转b得到   arbr，然后反转整个   得到(arbr)r的东西，   恰好是ba。这导致以下代码   旋转：

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

答案 23 :(得分：0)

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

答案 24 :(得分：0)

我一直在寻找解决此问题的方法。这解决了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

答案 25 :(得分：-3)

用于与其他语言中的shift类似的功能：

def shift(l):
    x = l[0]
    del(l[0])
    return x
相关问题
最新问题