在python中旋转列表的有效方法答案

【问题标题】：Efficient way to rotate a list in python在python中旋转列表的有效方法
【发布时间】：2011-01-10 03:25:59
【问题描述】：

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

有没有更好的办法？

【问题讨论】：

这并不是真正的转变，因为其他语言（Perl、Ruby）使用该术语。这是旋转。也许问题应该相应更新？
@dzhelil 我真的很喜欢你原来的解决方案，因为它不会引入突变
numpy.roll
我认为rotate 是正确的词，而不是shift。
真正的正确答案是，你不应该首先轮换列表。创建一个“指针”变量指向列表中您希望“头”或“尾”所在的逻辑位置，并更改该变量而不是移动列表中的任何项目。查找“模”运算符 % 以获得将指针“包裹”在列表开头和结尾的有效方法。

标签： python list

【解决方案1】：

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]

【讨论】：

对于未来的读者：collections.deque rotate() 比根据wiki.python.org/moin/TimeComplexity 切片要快
但请注意，使用deque.rotate 需要先将类型转换为deque 对象，这比l.append(l.pop(0)) 慢。因此，如果您有一个双端队列对象开始，请确保它是最快的。否则，使用l.append(l.pop(0))。
详细地说，deque.rotate 是 O(k) 但从列表到双端队列的类型转换是 O(n)。所以如果你从一个列表开始，使用 deque.rotate 是 O(n)+O(k)=O(n)。另一方面，l.append(l.pop(0)) 是 O(1)。
@Purrell，弹出前面的项目是 O(n)。在 wiki.python.org/moin/TimeComplexity 中，它被列为 O(k)，k 是列表中弹出项目之后的元素数，因为数据结构将所有后续元素移向列表的前面。由于这个原因，只能在 O(1) 时间内弹出最后一个元素。

【解决方案2】：

只使用pop(0) 怎么样？

list.pop([i])

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

【讨论】：

但是删除列表中的每个元素会不会花费 O(k)，其中 k 是剩余元素的数量。所以总时间将是 O(n^2) wiki.python.org/moin/TimeComplexity
这并不能真正回答问题。问题不在于按顺序返回项目，而在于创建一个以不同顺序排列的新列表。
不，使用 pop 的问题的答案是l.append(l.pop(0)。如果我没记错的话是 O(1)。
list.pop 内部调用 list_ass_slice ，它使用 memmove 非常快速地移动所有项目，但它仍然是 O(n)。请参阅 github.com/python/cpython/blob/master/Objects/listobject.c 和 wiki.python.org/moin/TimeComplexity。唯一可以在恒定时间内从 python 列表中删除的项目是最后一个。
投反对票。从docs.python.org/3/tutorial/… 也可以使用列表作为队列，其中添加的第一个元素是检索到的第一个元素（“先进先出”）；但是，列表对此目的无效。虽然从列表末尾追加和弹出很快，但从列表开头插入或弹出很慢（因为所有其他元素都必须移动一个）。

【解决方案3】：

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

【讨论】：

我喜欢 SO 的地方在于，有时在答案提要中，您可以找到一些像这样的新宝藏 :)
这个，当我测试它时，非常非常慢
@PeterHarrison：由于您不提供测试详细信息，因此很难知道您的意思。 This answer 提供完整的测试细节和时间比较。

【解决方案4】：

这取决于您在执行此操作时想要发生什么：

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

【讨论】：

注意：这将导致空列表崩溃。
n = n % len(seq) return = seq[-n:] + seq[:-n]
你能解释一下为什么 n = n%len(seq) 吗？
@AerysS 来解释大于列表计数的移位，即 7%5 = 2，因此我们将移位减少到 2，这与移位 7 次相同。

【解决方案5】：

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

a.append(a.pop(0))

【讨论】：

这是最快的列表方式。 collections.deque 更快，但对于单次迭代中最常见的列表长度情况，或多次迭代的任何情况，a.append(a.pop(0)) 将比类型转换为双端队列更快
@runDOSrun 对this question 的完美回答，遗憾的是，它已作为副本关闭。也许你会投票支持重新开放？

【解决方案6】：

只是一些关于时间的说明：

如果您从列表开始，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.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

表明从列表创建双端队列是 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)

如果你已经有双端队列对象：

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)

【讨论】：

而 list.pop() 是一个常数时间操作，而 list.pop(0) 是 not。它以相对于列表长度的线性时间运行。您可以通过修改 timeit 设置来测试：l = [random.random() for i in range(100000)]
list.pop 不是一个固定时间的操作。 list.pop 在 O(k) 时间内运行，其中 k 是删除元素之后的元素数，因此 list.pop(0) 是 O(n)。在内部，list.pop 使用 list_ass_slice，它使用 memmove 比使用 python 更快地移动项目，但对于长列表，它仍然非常耗时。见github.com/python/cpython/blob/master/Objects/listobject.c 和wiki.python.org/moin/TimeComplexity
感谢您的时间安排（和 cmets @emu）。那么我们可以说l.append(l.pop(0)) 是在将短列表（大约 7 个元素）移动一个方面表现最好的吗？
再次，关于l.append(l.pop(0)) 作为答案：This question 已作为副本关闭。也许你会投票支持重新开放？

【解决方案7】：

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

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

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

【讨论】：

【解决方案8】：

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

原来是凯莉邦迪的建议

tmp = data[shift:]
tmp += data[:shift]

在所有班次中都表现出色。

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

shift = 1:

shift = 100:

重现情节的代码：

import numpy
import perfplot
import collections


shift = 100


def list_append(data):
    return data[shift:] + data[:shift]


def list_append2(data):
    tmp = data[shift:]
    tmp += data[:shift]
    return tmp


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):
    data = data.copy()
    for _ in range(shift):
        data.append(data.pop(0))
    return data


b = perfplot.bench(
    setup=lambda n: numpy.random.rand(n).tolist(),
    kernels=[
        list_append,
        list_append2,
        roll,
        shift_concatenate,
        collections_deque,
        pop_append,
    ],
    n_range=[2 ** k for k in range(7, 20)],
    xlabel="len(data)",
)
b.show()
b.save("shift100.png")

【讨论】：

你构建的好工具。关于l.append(l.pop(0)) 作为答案：This question 作为副本关闭。也许你会投票支持重新开放？
这甚至更快：def tmp_del(data): tmp = data[:shift]; del data[:shift]; data += tmp; return data（在 n=1 时匹配 pop_append，在 n=10 时击败它，在 n=100 时击败 collections_deque）。
我看到你把“小”改成了“全部”。对于“大”班次，复制并删除短 suffix 并将其切片到前面可能要快得多。因此，理想情况下，首先要确定两个部分中哪一个更短，然后将其移出并移入。
哦，刚刚注意到您添加了data.copy() 和pop_append。对其他解决方案当然更公平，尽管现在它真的没有意义了。要创建一个新列表，它将是 tmp = data[shift:] tmp += data[:shift] return tmp。
这只是list_append 解决方案。

【解决方案9】：

这还取决于您是否要移动列表（改变它），或者您是否希望函数返回一个新列表。因为，根据我的测试，这样的事情至少比添加两个列表的实现快 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 有一些时间的各种实现

【讨论】：

我会选择del l[:n]，而不是l[:n] = []。只是一种选择。
哦，是的，好老德尔。我经常忘记del；列表操作是一个语句，而不是一个方法。 py3k 改变了这个怪癖，还是我们仍然得到它？
@keturn: del 在 Py3 中仍然是一个声明。但是x.__delitem__(y) <==> del x[y]，所以如果您更喜欢使用方法，l.__delitem__(slice(n)) 也是等效的，并且适用于 2 和 3。

【解决方案10】：

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

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】：

可能环形缓冲区更合适。它不是一个列表，尽管它的行为可能足以满足您的目的。

问题在于列表上的移位效率为 O(n)，这对于足够大的列表非常重要。

在环形缓冲区中移动只是更新 O(1) 的头部位置

【讨论】：

【解决方案12】：

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

数组没有列表的开销。

就纯粹的列表而言，您所拥有的与您希望做的一样好。

【讨论】：

【解决方案13】：

我想你正在寻找这个：

a.insert(0, x)

【讨论】：

我看不出问题与您的答案之间的关系。你能解释一下吗？

【解决方案14】：

另一种选择：

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

【讨论】：

【解决方案15】：

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]

【讨论】：

【解决方案16】：

我以这个成本模型作为参考：

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)

【讨论】：

更新：将此作为更好的参考：wiki.python.org/moin/TimeComplexity，使用collections.dequeue pop 和 appendleft，它们都是 O(1) 操作。在我上面的第一个答案中，插入是 O(n)。
应该是collections.deque

【解决方案17】：

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

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() 也会改变 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。我不知道这是否是一个错误，但我认为我更有可能在这里误解了一些东西。

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

【讨论】：

发生这种情况是因为x.classlist = otherlist 使x.classlist 引用与otherlist 相同的列表，然后当您调用x.shift_classlist() 时它会改变列表，因为这两个名称都引用相同的列表对象。这两个名称似乎都发生了变化，因为它们只是同一个对象的别名。请改用x.classlist = otherlist[:] 来分配列表的副本。
嘿哇！非常感谢！我真的不知道，知道真的很好！ :)

【解决方案18】：

下面的方法是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 中，与其他方法相比，这种方法效率极低，因为它无法利用任何部分的本机实现。

【讨论】：

好吧，实际上你可以使用 list.pop 和 list.append。你写了一个 O(n) 的 12 行函数，这不是语言的错，而你本可以只写恒定时间的“l.append(l.pop(0))”。
l.append(l.pop(0)) 是 O(n) （l.pop(0) 必须移动每个元素），因此如果你想移动 m 值，复杂性实际上是O(n*m)。我提供的算法的复杂度是 O(n)，不管班次多少。在实践中，这很慢，因为太多逻辑是在 python ops 而不是 C 中完成的（list.pop 是在 c 中实现的，请参阅github.com/python/cpython/blob/master/Objects/listobject.c）。

【解决方案19】：

我也有类似的事情。例如，移动两个...

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

【讨论】：

【解决方案20】：

我认为你有最有效的方法

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

【讨论】：

【解决方案21】：

Jon Bentley 在Programming Pearls（第 2 列）中描述了一种优雅而高效的算法，用于将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']

【讨论】：

【解决方案22】：

我一直在寻找这个问题的适当解决方案。这解决了 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

【讨论】：

【解决方案23】：

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

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

【讨论】：

【解决方案24】：

以下函数将已发送列表复制到临时列表中，因此弹出功能不会影响原始列表：

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]

【讨论】：

【解决方案25】：

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

【讨论】：

这正是 OP 所拥有的。您只是更改了名称并添加了一个断言。
您回答中的函数list_shift 与原始问题中的函数shift 相同，因此这不是对实际问题的回答：“有没有更好的方法？”跨度>

【解决方案26】：

我是“老派”，我将效率定义为最低延迟、处理器时间和内存使用率，我们的克星是臃肿的库。所以只有一种正确的方法：

    def rotatel(nums):
        back = nums.pop(0)
        nums.append(back)
        return nums

【讨论】：