如何生成列表的所有排列？

此解决方案实现了一个生成器，以避免将所有排列保存在内存中：

def permutations (orig_list):if not isinstance(orig_list, list):orig_list = list(orig_list)
yield orig_list
if len(orig_list) == 1:return
for n in sorted(orig_list):new_list = orig_list[:]pos = new_list.index(n)del(new_list[pos])new_list.insert(0, n)for resto in permutations(new_list[1:]):if new_list[:1] + resto <> orig_list:yield new_list[:1] + resto

使用标准库中的itertools.permutations：

import itertoolslist(itertools.permutations([1, 2, 3]))

改编自这里是如何实现itertools.permutations的演示：

def permutations(elements):if len(elements) <= 1:yield elementsreturnfor perm in permutations(elements[1:]):for i in range(len(elements)):# nb elements[0:1] works in both string and list contextsyield perm[:i] + elements[0:1] + perm[i:]

itertools.permutations的留档中列出了几种替代方法。这里有一个：

def permutations(iterable, r=None):# permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC# permutations(range(3)) --> 012 021 102 120 201 210pool = tuple(iterable)n = len(pool)r = n if r is None else rif r > n:returnindices = range(n)cycles = range(n, n-r, -1)yield tuple(pool[i] for i in indices[:r])while n:for i in reversed(range(r)):cycles[i] -= 1if cycles[i] == 0:indices[i:] = indices[i+1:] + indices[i:i+1]cycles[i] = n - ielse:j = cycles[i]indices[i], indices[-j] = indices[-j], indices[i]yield tuple(pool[i] for i in indices[:r])breakelse:return

另一个，基于itertools.product：

def permutations(iterable, r=None):pool = tuple(iterable)n = len(pool)r = n if r is None else rfor indices in product(range(n), repeat=r):if len(set(indices)) == r:yield tuple(pool[i] for i in indices)

从python2.6开始：

import itertoolsitertools.permutations([1, 2, 3])

这将作为生成器返回。使用list(permutations(xs))作为列表返回。

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

def permute_in_place(a):a.sort()yield list(a)
if len(a) <= 1:return
first = 0last = len(a)while 1:i = last - 1
while 1:i = i - 1if a[i] < a[i+1]:j = last - 1while not (a[i] < a[j]):j = j - 1a[i], a[j] = a[j], a[i] # swap the valuesr = a[i+1:last]r.reverse()a[i+1:last] = ryield list(a)breakif i == first:a.reverse()return
if __name__ == '__main__':for n in range(5):for a in permute_in_place(range(1, n+1)):print aprint
for a in permute_in_place([0, 0, 1, 1, 1]):print aprint

首先导入itertools：

import itertools

排列（顺序事项）：

print(list(itertools.permutations([1,2,3,4], 2)))
[(1, 2), (1, 3), (1, 4),(2, 1), (2, 3), (2, 4),(3, 1), (3, 2), (3, 4),(4, 1), (4, 2), (4, 3)]

组合（顺序无关紧要）：

print(list(itertools.combinations('123', 2)))
[('1', '2'), ('1', '3'), ('2', '3')]

笛卡尔积（具有多个可迭代项）：

print(list(itertools.product([1,2,3], [4,5,6])))
[(1, 4), (1, 5), (1, 6),(2, 4), (2, 5), (2, 6),(3, 4), (3, 5), (3, 6)]

笛卡尔积（有一个可迭代的和它自己）：

print(list(itertools.product([1,2], repeat=3)))
[(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),(2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]

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

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

list2Perm = [1, 2.0, 'three']listPerm = [[a, b, c]for a in list2Permfor b in list2Permfor c in list2Permif ( a != b and b != c and a != c )]print listPerm

输出：

[[1, 2.0, 'three'],[1, 'three', 2.0],[2.0, 1, 'three'],[2.0, 'three', 1],['three', 1, 2.0],['three', 2.0, 1]]

def permutations(head, tail=''):if len(head) == 0:print(tail)else:for i in range(len(head)):permutations(head[:i] + head[i+1:], tail + head[i])

称为：

permutations('abc')

确实可以迭代每个排列的第一个元素，就像tzwenn的回答一样。然而，这样写这个解决方案更有效：

def all_perms(elements):if len(elements) <= 1:yield elements  # Only permutation possible = no permutationelse:# 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(elements) <= 1而不是0结尾的递归。它也更节省内存，因为它使用生成器函数（通过yield），就像Riccardo Reyes的解决方案一样。

#!/usr/bin/env python
def perm(a, k=0):if k == len(a):print aelse:for i in xrange(k, len(a)):a[k], a[i] = a[i] ,a[k]perm(a, k+1)a[k], a[i] = a[i], a[k]
perm([1,2,3])

输出：

[1, 2, 3][1, 3, 2][2, 1, 3][2, 3, 1][3, 2, 1][3, 1, 2]

当我交换列表的内容时，它需要一个可变的序列类型作为输入。例如。perm(list("ball"))可以，perm("ball")不行，因为你不能更改字符串。

这个Python实现的灵感来自Horowitz、Sahni和Rajasekeran的计算机算法一书中提出的算法。

请注意，此算法的时间复杂度为n factorial，其中n是输入列表的长度

在运行中打印结果：

global resultresult = []
def permutation(li):if li == [] or li == None:return
if len(li) == 1:result.append(li[0])print resultresult.pop()return
for i in range(0,len(li)):result.append(li[i])permutation(li[:i] + li[i+1:])result.pop()

示例：

permutation([1,2,3])

输出：

[1, 2, 3][1, 3, 2][2, 1, 3][2, 3, 1][3, 1, 2][3, 2, 1]

from __future__ import print_function
def perm(n):p = []for i in range(0,n+1):p.append(i)while True:for i in range(1,n+1):print(p[i], end=' ')print("")i = n - 1found = 0while (not found and i>0):if p[i]<p[i+1]:found = 1else:i = i - 1k = nwhile p[i]>p[k]:k = k - 1aux = p[i]p[i] = p[k]p[k] = auxfor j in range(1,(n-i)/2+1):aux = p[i+j]p[i+j] = p[n-j+1]p[n-j+1] = auxif not found:break
perm(5)

在功能风格

def addperm(x,l):return [ l[0:i] + [x] + l[i:]  for i in range(len(l)+1) ]
def perm(l):if len(l) == 0:return [[]]return [x for y in perm(l[1:]) for x in addperm(l[0],y) ]
print perm([ i for i in range(3)])

结果：

[[0, 1, 2], [1, 0, 2], [1, 2, 0], [0, 2, 1], [2, 0, 1], [2, 1, 0]]

这是一个在列表上工作的算法，而不会创建新的中间列表，类似于Ber在https://stackoverflow.com/a/108651/184528的解决方案。

def permute(xs, low=0):if low + 1 >= len(xs):yield xselse:for p in permute(xs, low + 1):yield pfor i in range(low + 1, len(xs)):xs[low], xs[i] = xs[i], xs[low]for p in permute(xs, low + 1):yield pxs[low], xs[i] = xs[i], xs[low]
for p in permute([1, 2, 3, 4]):print p

您可以在此处自行尝试代码：http://repl.it/J9v

我使用了一个基于阶乘数系-的算法对于长度为n的列表，你可以逐项组装每个排列，从每个阶段剩下的项目中进行选择。第一项有n个选择，第二项有n-1个，最后一项只有一个，所以你可以使用阶乘数字系统中数字的数字作为索引。这样，数字0到n！-1对应于字典顺序中所有可能的排列。

from math import factorialdef permutations(l):permutations=[]length=len(l)for x in xrange(factorial(length)):available=list(l)newPermutation=[]for radix in xrange(length, 0, -1):placeValue=factorial(radix-1)index=x/placeValuenewPermutation.append(available.pop(index))x-=index*placeValuepermutations.append(newPermutation)return permutations
permutations(range(3))

输出：

[[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]

这种方法是非递归的，但在我的计算机上稍微慢一点，当n！太大而无法转换为C长整数（对我来说n=13）时，xrange会引发错误。当我需要它的时候，这就足够了，但它itertools.permutations。

这是受使用列表理解的Haskell实现的启发：

def permutation(list):if len(list) == 0:return [[]]else:return [[x] + ys for x in list for ys in permutation(delete(list, x))]
def delete(list, item):lc = list[:]lc.remove(item)return lc

递归之美：

>>> import copy>>> def perm(prefix,rest):...      for e in rest:...              new_rest=copy.copy(rest)...              new_prefix=copy.copy(prefix)...              new_prefix.append(e)...              new_rest.remove(e)...              if len(new_rest) == 0:...                      print new_prefix + new_rest...                      continue...              perm(new_prefix,new_rest)...>>> perm([],['a','b','c','d'])['a', 'b', 'c', 'd']['a', 'b', 'd', 'c']['a', 'c', 'b', 'd']['a', 'c', 'd', 'b']['a', 'd', 'b', 'c']['a', 'd', 'c', 'b']['b', 'a', 'c', 'd']['b', 'a', 'd', 'c']['b', 'c', 'a', 'd']['b', 'c', 'd', 'a']['b', 'd', 'a', 'c']['b', 'd', 'c', 'a']['c', 'a', 'b', 'd']['c', 'a', 'd', 'b']['c', 'b', 'a', 'd']['c', 'b', 'd', 'a']['c', 'd', 'a', 'b']['c', 'd', 'b', 'a']['d', 'a', 'b', 'c']['d', 'a', 'c', 'b']['d', 'b', 'a', 'c']['d', 'b', 'c', 'a']['d', 'c', 'a', 'b']['d', 'c', 'b', 'a']

这个算法是最有效的，它避免了递归调用中的数组传递和操作，适用于Python 2,3：

def permute(items):length = len(items)def inner(ix=[]):do_yield = len(ix) == length - 1for i in range(0, length):if i in ix: #avoid duplicatescontinueif do_yield:yield tuple([items[y] for y in ix + [i]])else:for p in inner(ix + [i]):yield preturn inner()

用法：

for p in permute((1,2,3)):print(p)
(1, 2, 3)(1, 3, 2)(2, 1, 3)(2, 3, 1)(3, 1, 2)(3, 2, 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 seqelse:return pzip(seq[0], perm(seq[1:]))

对于性能，受高德纳启发的numpy解决方案（p22）：

from numpy import empty, uint8from math import factorial
def perms(n):f = 1p = empty((2*n-1, factorial(n)), uint8)for i in range(n):p[i, :f] = ip[i+1:2*i+1, :f] = p[:i, :f]  # constitution de blocsfor j in range(i):p[:i+1, f*(j+1):f*(j+2)] = p[j+1:j+i+2, :f]  # copie de blocsf = f*(i+1)return p[:n, :]

复制大量内存可以节省时间-比list(itertools.permutations(range(n))快20倍：

In [1]: %timeit -n10 list(permutations(range(10)))10 loops, best of 3: 815 ms per loop
In [2]: %timeit -n100 perms(10)100 loops, best of 3: 40 ms per loop

对于Python，我们可以使用iter工具并导入排列和组合来解决您的问题

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

生成所有可能的排列

我正在使用python3.4：

def calcperm(arr, size):result = set([()])for dummy_idx in range(size):temp = set()for dummy_lst in result:for dummy_outcome in arr:if dummy_outcome not in dummy_lst:new_seq = list(dummy_lst)new_seq.append(dummy_outcome)temp.add(tuple(new_seq))result = tempreturn result

测试用例：

lst = [1, 2, 3, 4]#lst = ["yellow", "magenta", "white", "blue"]seq = 2final = calcperm(lst, seq)print(len(final))print(final)

我看到在这些递归函数中进行了很多次迭代，而不是纯次递归…

所以对于那些连一个循环都不能遵守的人，这里有一个粗略的，完全不必要的完全递归的解决方案

def all_insert(x, e, i=0):return [x[0:i]+[e]+x[i:]] + all_insert(x,e,i+1) if i<len(x)+1 else []
def for_each(X, e):return all_insert(X[0], e) + for_each(X[1:],e) if X else []
def permute(x):return [x] if len(x) < 2 else for_each( permute(x[1:]) , x[0])

perms = permute([1,2,3])

另一种解决方案：

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

我的Python解决方案：

def permutes(input,offset):if( len(input) == offset ):return [''.join(input)]
result=[]for i in range( offset, len(input) ):input[offset], input[i] = input[i], input[offset]result = result + permutes(input,offset+1)input[offset], input[i] = input[i], input[offset]return result
# input is a "string"# return value is a list of stringsdef permutations(input):return permutes( list(input), 0 )
# Main Programprint( permutations("wxyz") )

def permutation(word, first_char=None):if word == None or len(word) == 0: return []if len(word) == 1: return [word]
result = []first_char = word[0]for sub_word in permutation(word[1:], first_char):result += insert(first_char, sub_word)return sorted(result)
def insert(ch, sub_word):arr = [ch + sub_word]for i in range(len(sub_word)):arr.append(sub_word[i:] + ch + sub_word[:i])return arr

assert permutation(None) == []assert permutation('') == []assert permutation('1')  == ['1']assert permutation('12') == ['12', '21']
print permutation('abc')

输出：['abc'，'acb'，'bac'，'bca'，'出租车'，'cba']

为了节省您可能的搜索和实验时间，以下是Python中的非递归perMutaions解决方案，它也适用于Numba（从0.41开始）：

@numba.njit()def permutations(A, k):r = [[i for i in range(0)]]for i in range(k):r = [[a] + b for a in A for b in r if (a in b)==False]return rpermutations([1,2,3],3)[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

给人留下关于性能的印象：

%timeit permutations(np.arange(5),5)
243 µs ± 11.1 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)time: 406 ms
%timeit list(itertools.permutations(np.arange(5),5))15.9 µs ± 8.61 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)time: 12.9 s

因此，仅当您必须从NJITED函数调用它时才使用此版本，否则更喜欢迭代工具实现。

使用Counter

from collections import Counter
def permutations(nums):ans = [[]]cache = Counter(nums)
for idx, x in enumerate(nums):result = []for items in ans:cache1 = Counter(items)for id, n in enumerate(nums):if cache[n] != cache1[n] and items + [n] not in result:result.append(items + [n])
ans = resultreturn anspermutations([1, 2, 2])> [[1, 2, 2], [2, 1, 2], [2, 2, 1]]

另一种方法（没有libs）

def permutation(input):if len(input) == 1:return input if isinstance(input, list) else [input]
result = []for i in range(len(input)):first = input[i]rest = input[:i] + input[i + 1:]rest_permutation = permutation(rest)for p in rest_permutation:result.append(first + p)return result

输入可以是字符串或列表

print(permutation('abcd'))print(permutation(['a', 'b', 'c', 'd']))

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

小跑包与大多数实现的不同之处在于，它生成的伪列表实际上并不包含排列，而是描述排列和排序中相应位置之间的映射，使得处理非常大的排列“列表”成为可能，如这个demo所示，它在包含字母表中所有字母排列的伪列表中执行非常即时的操作和查找，而无需使用比典型网页更多的内存或处理。

无论如何，要生成排列列表，我们可以执行以下操作。

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 getPermutations(array):if len(array) == 1:return [array]permutations = []for i in range(len(array)):# get all perm's of subarray w/o current itemperms = getPermutations(array[:i] + array[i+1:])for p in perms:permutations.append([array[i], *p])return permutations

产量实现：

def getPermutations(array):if len(array) == 1:yield arrayelse:for i in range(len(array)):perms = getPermutations(array[:i] + array[i+1:])for p in perms:yield [array[i], *p]

基本思想是遍历数组中第一个位置的所有元素，然后在第二个位置遍历所有其余元素，而不选择第一个元素，等等，您可以使用递归执行此操作，其中停止条件是获取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

我不打算用尽每一个可能性在一个新的行，使它有点独特。

无论如何，我们可以使用症状库，也支持多集排列

import sympyfrom sympy.utilities.iterables import multiset_permutationst = [1,2,3]p = list(multiset_permutations(t))print(p)
# [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

答案受到获取numpy数组的所有排列的高度启发

from typing import Listimport time, random
def measure_time(func):def wrapper_time(*args, **kwargs):start_time = time.perf_counter()res = func(*args, **kwargs)end_time = time.perf_counter()return res, end_time - start_time
return wrapper_time

class Solution:def permute(self, nums: List[int], method: int = 1) -> List[List[int]]:perms = []perm = []if method == 1:_, time_perm = self._permute_recur(nums, 0, len(nums) - 1, perms)elif method == 2:_, time_perm = self._permute_recur_agian(nums, perm, perms)print(perm)return perms, time_perm
@measure_timedef _permute_recur(self, nums: List[int], l: int, r: int, perms: List[List[int]]):# base caseif l == r:perms.append(nums.copy())
for i in range(l, r + 1):nums[l], nums[i] = nums[i], nums[l]self._permute_recur(nums, l + 1, r , perms)nums[l], nums[i] = nums[i], nums[l]
@measure_timedef _permute_recur_agian(self, nums: List[int], perm: List[int], perms_list: List[List[int]]):"""The idea is similar to nestedForLoops visualized as a recursion tree."""if nums:for i in range(len(nums)):# perm.append(nums[i])  mistake, perm will be filled with all nums's elements.# Method1 perm_copy = copy.deepcopy(perm)# Method2 add in the parameter list using + (not in place)# caveat: list.append is in-place , which is useful for operating on global element perms_list# Note that:# perms_list pass by reference. shallow copy# perm + [nums[i]] pass by value instead of reference.self._permute_recur_agian(nums[:i] + nums[i+1:], perm + [nums[i]], perms_list)else:# Arrive at the last loop, i.e. leaf of the recursion tree.perms_list.append(perm)


if __name__ == "__main__":array = [random.randint(-10, 10) for _ in range(3)]sol = Solution()# perms, time_perm = sol.permute(array, 1)perms2, time_perm2 = sol.permute(array, 2)print(perms2)# print(perms, perms2)# print(time_perm, time_perm2)```

如果有人喜欢这个丑陋的单行代码（仅适用于字符串）：

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

这是O（n*n！）在初始排序后生成排列的渐近最优方式。

最多有n个！排列，并且hasNextPerMutation（…）以O（n）时间复杂度运行

在3个步骤中，

1. 求最大的j，使得a[j]可以增加
2. 通过最小可行量增加a[j]
3. 找到词典总体上最小的方法来扩展新的a[0… j]

'''Lexicographic permutation generation
consider example array state of [1,5,6,4,3,2] for sorted [1,2,3,4,5,6]after 56432(treat as number) ->nothing larger than 6432(using 6,4,3,2) beginning with 5so 6 is next larger and 2345(least using numbers other than 6)so [1, 6,2,3,4,5]'''def hasNextPermutation(array, len):' Base Condition 'if(len ==1):return False'''Set j = last-2 and find first j such that a[j] < a[j+1]If no such j(j==-1) then we have visited all permutationsafter this step a[j+1]>=..>=a[len-1] and a[j]<a[j+1]
a[j]=5 or j=1, 6>5>4>3>2'''j = len -2while (j >= 0 and array[j] >= array[j + 1]):j= j-1if(j==-1):return False# print(f"After step 2 for j {j}  {array}")'''decrease l (from n-1 to j) repeatedly until a[j]<a[l]Then swap a[j], a[l]a[l] is the smallest element > a[j] that can follow a[l]...a[j-1] in permutationbefore swap we have a[j+1]>=..>=a[l-1]>=a[l]>a[j]>=a[l+1]>=..>=a[len-1]after swap -> a[j+1]>=..>=a[l-1]>=a[j]>a[l]>=a[l+1]>=..>=a[len-1]
a[l]=6 or l=2, j=1 just before swap [1, 5, 6, 4, 3, 2]after swap [1, 6, 5, 4, 3, 2] a[l]=5, a[j]=6'''l = len -1while(array[j] >= array[l]):l = l-1# print(f"After step 3 for l={l}, j={j} before swap {array}")array[j], array[l] = array[l], array[j]# print(f"After step 3 for l={l} j={j} after swap {array}")'''Reverse a[j+1...len-1](both inclusive)
after reversing [1, 6, 2, 3, 4, 5]'''array[j+1:len] = reversed(array[j+1:len])# print(f"After step 4 reversing {array}")return True
array = [1,2,4,4,5]array.sort()len = len(array)count =1print(array)'''The algorithm visits every permutation in lexicographic ordergenerating one by one'''while(hasNextPermutation(array, len)):print(array)count = count +1# The number of permutations will be n! if no duplicates are present, else less than that# [1,4,3,3,2] -> 5!/2!=60print(f"Number of permutations: {count}")

如果您不想使用内置方法，例如：

import itertoolslist(itertools.permutations([1, 2, 3]))

你可以自己实现permute函数

from collections.abc import Iterable

def permute(iterable: Iterable[str]) -> set[str]:perms = set()
if len(iterable) == 1:return {*iterable}
for index, char in enumerate(iterable):perms.update([char + perm for perm in permute(iterable[:index] + iterable[index + 1:])])
return perms

if __name__ == '__main__':print(permute('abc'))# {'bca', 'abc', 'cab', 'acb', 'cba', 'bac'}print(permute(['1', '2', '3']))# {'123', '312', '132', '321', '213', '231'}

def permutate(l):for i, x in enumerate(l):for y in l[i + 1:]:yield x, y

if __name__ == '__main__':print(list(permutate(list('abcd'))))print(list(permutate([1, 2, 3, 4])))
#[('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd')]#[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

用递归求解，遍历元素，取第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

如果用户想将所有排列保留在列表中，可以使用以下代码：

def get_permutations(nums, p_list=[], temp_items=[]):if not nums:returnelif len(nums) == 1:new_items = temp_items+[nums[0]]p_list.append(new_items)returnelse:for i in range(len(nums)):temp_nums = nums[:i]+nums[i+1:]new_temp_items = temp_items + [nums[i]]get_permutations(temp_nums, p_list, new_temp_items)
nums = [1,2,3]p_list = []
get_permutations(nums, p_list)