如果有人喜欢这个丑陋的单行线（虽然只适用于字符串）：

def p(a):
    return a if len(a) == 1 else [[a[i], *j] for i in range(len(a)) for j in p(a[:i] + a[i + 1:])]

def pzip(c, seq):
    result = []
    for item in seq:
        for i in range(len(item)+1):
            result.append(item[i:]+c+item[:i])
    return result


def perm(line):
    seq = [c for c in line]
    if len(seq) <=1 :
        return seq
    else:
        return pzip(seq[0], perm(seq[1:]))

def permuteArray (arr):

    arraySize = len(arr)

    permutedList = []

    if arraySize == 1:
        return [arr]

    i = 0

    for item in arr:

        for elem in permuteArray(arr[:i] + arr[i + 1:]):
            permutedList.append([item] + elem)

        i = i + 1    

    return permutedList

我不打算在一个新的行中穷尽所有的可能性，以使它有点独特。

人们确实可以对每个排列的第一个元素进行迭代，正如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]

对于Python，我们可以使用itertools并导入排列和组合来解决问题

from itertools import product, permutations
A = ([1,2,3])
print (list(permutations(sorted(A),2)))