另一种解决方案：

def permutation(flag, k =1 ):
    N = len(flag)
    for i in xrange(0, N):
        if flag[i] != 0:
            continue
        flag[i] = k 
        if k == N:
            print flag
        permutation(flag, k+1)
        flag[i] = 0

permutation([0, 0, 0])

用递归求解，遍历元素，取第i个元素，然后问自己：“其余项目的排列是什么”，直到没有更多的元素。

我在这里解释了解决方案：https://www.youtube.com/watch?v=_7GE7psS2b4

class Solution:
    def permute(self,nums:List[int])->List[List[int]]:
        res=[]
        def dfs(nums,path):
            if len(nums)==0:
                res.append(path)
            for i in range(len(nums)):
                dfs(nums[:i]+nums[i+1:],path+[nums[i]])
        dfs(nums,[])
        return res

人们确实可以对每个排列的第一个元素进行迭代，正如tzwen的答案。然而，这样编写此解决方案更有效：

def all_perms(elements):
    if len(elements) <= 1:
        yield elements  # Only permutation possible = no permutation
    else:
        # Iteration over the first element in the result permutation:
        for (index, first_elmt) in enumerate(elements):
            other_elmts = elements[:index]+elements[index+1:]
            for permutation in all_perms(other_elmts): 
                yield [first_elmt] + permutation

这个解决方案大约快了30%，显然是因为递归以len（元素）<=1而不是0结尾。它的内存效率也高得多，因为它使用了一个生成器函数（通过yield），就像Riccardo Reyes的解决方案一样。

免责声明：无耻的插件由包作者。：）

trotter包与大多数实现的不同之处在于，它生成的伪列表实际上不包含排列，而是描述排列与排序中各个位置之间的映射，从而可以处理非常大的排列“列表”，如本演示所示，它在一个包含字母表中所有字母排列的伪列表中执行相当即时的操作和查找，而不使用比典型网页更多的内存或处理。

在任何情况下，要生成排列列表，我们可以执行以下操作。

import trotter

my_permutations = trotter.Permutations(3, [1, 2, 3])

print(my_permutations)

for p in my_permutations:
    print(p)

输出：

A pseudo-list containing 6 3-permutations of [1, 2, 3].
[1, 2, 3]
[1, 3, 2]
[3, 1, 2]
[3, 2, 1]
[2, 3, 1]
[2, 1, 3]

在我看来，一个很明显的方式可能是：

def permutList(l):
    if not l:
            return [[]]
    res = []
    for e in l:
            temp = l[:]
            temp.remove(e)
            res.extend([[e] + r for r in permutList(temp)])

    return res

以下代码是给定列表的就地排列，作为生成器实现。由于它只返回对列表的引用，因此不应在生成器外部修改列表。该解决方案是非递归的，因此使用了低内存。还可以很好地处理输入列表中元素的多个副本。

def permute_in_place(a):
    a.sort()
    yield list(a)

    if len(a) <= 1:
        return

    first = 0
    last = len(a)
    while 1:
        i = last - 1

        while 1:
            i = i - 1
            if a[i] < a[i+1]:
                j = last - 1
                while not (a[i] < a[j]):
                    j = j - 1
                a[i], a[j] = a[j], a[i] # swap the values
                r = a[i+1:last]
                r.reverse()
                a[i+1:last] = r
                yield list(a)
                break
            if i == first:
                a.reverse()
                return

if __name__ == '__main__':
    for n in range(5):
        for a in permute_in_place(range(1, n+1)):
            print a
        print

    for a in permute_in_place([0, 0, 1, 1, 1]):
        print a
    print