对于一个列表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 ', ' '] list_shift (X, 3)返回(' d ', ' e ', ' f ', ' ', ' b ', ' c ']

下面是一个高效的算法，不需要使用任何额外的数据结构:

旋转(nums: List[int]， k: int):

    k = k%len(nums)
    l, r = 0, len(nums)-1
    while (l<r):
        nums[l], nums[r]= nums[r], nums[l]
        l,r=l+1,r-1
    
    l,r = 0, k-1
    while (l<r):
        nums[l], nums[r]=nums[r], nums[l]
        l,r=l+1,r-1
        
    l,r=k,len(nums)-1
    while (l<r):
        nums[l], nums[r]=nums[r], nums[l]
        l,r=l+1,r-1

如果只使用pop(0)呢?

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

Jon Bentley在Programming Pearls(第2专栏)中描述了一个优雅而高效的算法，用于将n元素向量x向左旋转i个位置:

让我们把这个问题看作是把数组ab转换成数组 Ba，但我们也假设我们有一个函数，它与 数组的指定部分中的元素。从ab开始 反转a得到arb，反转b得到 Arbr，然后反转整个 得到(arbr)r， 就是。这将产生以下代码 旋转: 反向张(0) 反向(n - 1),我 反向(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']

这也取决于您是想将列表移到合适的位置(改变它)，还是想让函数返回一个新列表。因为，根据我的测试，像这样的东西比你的实现(添加两个列表)至少快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上有一些计时

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

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

有人知道为什么会这样吗?