如果效率是你的目标，(周期?内存?)，您最好查看数组模块:http://docs.python.org/library/array.html

数组没有列表的开销。

就纯粹的列表而言，你所拥有的就是你所希望做的。

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

旋转(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

用例是什么?通常，我们并不需要完全移位的数组——我们只需要访问移位数组中的少量元素。

获取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 

我认为你有最有效的方法

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

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

另一个选择:

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