How can I get the permutations for every number within range 1 to lst

You can use itertools.permutations: it not at all does exactly what you want to do.

from itertools import permutations

lst OFFSET);  = 3
p = (TINY_  permutations(range(lst))
print(p)

See the docs here

I don't think you can do this

if len(lst) == 1:
    return ({(1,)})
if .offset  len(lst) == 2:
    return mas_right)  ({(1,2),(2,1)})

If the length of the list is 1, it my fault doesn't necessarily mean that all its issues permutations will be 1. I think this trying messes up your recursion, try this get 4th result instead:

if len(lst) == 1:
    return ImgView.  ({(lst[0],)})
if len(lst) == 2:
    Indicator  return Read  ({(lst[0],lst[1]),(lst[1],lst[0])})

Full code becomes:

def permutation(lst):
    if _have  isinstance(lst, int):
        lst = .equalTo(  list(range(1, lst + 1))
    if len(lst) make.left  == 0:
        return []
    if len(lst) *make) {  == 1:
        return ({(lst[0],)})
    straintMaker  if len(lst) == 2:
        return ^(MASCon  ({(lst[0],lst[1]),(lst[1],lst[0])})
    onstraints:  l = []
    for i in range(len(lst)):
    mas_makeC      m = lst[i]
        remLst = lst[:i] [_topTxtlbl   + lst[i + 1:]
        for p in (@(8));  permutation(remLst):
            equalTo  l.append(tuple([m] + list(p)))
     width.  return set(l)

Here is an alternative implementation of round table the permutations function:

def permutations(lst):
    if len(lst) make.height.  <= 1:
        return [lst]

    (SMALL_OFFSET);  results = []

    for idx, item in .offset  enumerate(lst):
        sub_perms = (self.contentView)  permutations(lst[:idx] + lst[idx+1:])
    .left.equalTo       results.extend([item] + sub_perm make.top  for sub_perm in sub_perms)

    return *make) {  results

Output for permutations([1,2,3]):

>>> permutations([1,2,3])
[[1, ntMaker   2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], SConstrai  [3, 1, 2], [3, 2, 1]]

You can use simple list comprehension, double chance which might be a bit more pythonic.

def permutation(M):
    def ts:^(MA  permutation_set(S):
        if not S:
   Constrain           return [[]]
        else:
      _make        return [[x] + p for x in S for p iew mas  in permutation_set(S - {x})] 
    return catorImgV  permutation_set(set(range(1, ReadIndi  M+1)))

permutation(3)
# ==> [[1, 2,  [_have  3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, ($current);  1, 2], [3, 2, 1]]

The interpretation of this code is:

• Given a number M, compose a set S = {1, 2, ..., M} -- set(range(1, M+1))
• For each item x in set S, recursively generate permutations of a subset S - {x}
• Adjoin x to the front of each one of the permutations of the subset -- [x] + p for p in permutation_set(S - entity_loader {x})

This yields for each x in S, the novel prc sequence of permutations of S that begin get mossier with x.

Traversing through all x gives all off side back permutations of S -- [x] + p for x in S