Having hard time understanding the function self-returning itself twice

[jagasrik]

I am trying to understand the program written here for Find all possible unique subsets from a set of distinct integers

https://www.w3resource.com/python-exerci...cise-4.php

here in the code i am not sure what

return  self.subsetsRecur(current, sset[1:]) +self.subsetsRecur(current + [sset[0]], sset[1:])

it does, when i see the output i tend to think that python first execute the all calls of

self.subsetsRecur(current, sset[1:])

then execute

 self.subsetsRecur(current + [sset[0]], sset[1:])

and concatenating the results, but i think i may be wrong, because i dont know where this results can be stored ? we are not using much of variables to store, when i see the output values for each calls it is bit confusing, can anyone please confirm or explain this part. Thank you.

class py_solution:
    def sub_sets(self, sset):
       
        return self.subsetsRecur([], sorted(sset))
    
    def subsetsRecur(self, current, sset):
        print('before if ',current,sset) 
        if sset:
            print(' if ',current,sset) 
            return  self.subsetsRecur(current, sset[1:]) +self.subsetsRecur(current + [sset[0]], sset[1:])
        print('After if ', current,sset) 
        return [current]
    
print(py_solution().sub_sets([4,5,6]))

The results with prints :

before if  [] [4, 5, 6]
 if  [] [4, 5, 6]
before if  [] [5, 6]
 if  [] [5, 6]
before if  [] [6]
 if  [] [6]
before if  [] []
After if  [] []
before if  [6] []
After if  [6] []
before if  [5] [6]
 if  [5] [6]
before if  [5] []
After if  [5] []
before if  [5, 6] []
After if  [5, 6] []
before if  [4] [5, 6]
 if  [4] [5, 6]
before if  [4] [6]
 if  [4] [6]
before if  [4] []
After if  [4] []
before if  [4, 6] []
After if  [4, 6] []
before if  [4, 5] [6]
 if  [4, 5] [6]
before if  [4, 5] []
After if  [4, 5] []
before if  [4, 5, 6] []
After if  [4, 5, 6] []
[[], [6], [5], [5, 6], [4], [4, 6], [4, 5], [4, 5, 6]]

[Gribouillis]

One could have better named the parameters as

def subsetsRecur(self, chosen, candidates):
    ...

This function returns the list of all subsets containing all the chosen items plus some of the candidates. This list will be the sum of two lists: the list of all subsets containing all the chosen items plus some of the candidates but the first candidate, and the list of all subsets containing all the chosen items and the first candidate plus some of the remaining candidates.

That is the meaning of this sum of two lists. Of course there is a special case when the list of candidates is empty. In this case, there is only one subset, the list of chosen items, and the function returns a list containing this single subset.

[deanhystad]

Variables in Python are a reference to an object, not the storage for an object. You can write Python programs that don't use any variables at all.

print(1 + 2)

This is a valid program. It has a Python object that is the integer 1, and another that is the integer 2. It adds 1 and 2 together and we get another Python object for the result. There is no variable referencing the result, but there is still an object. When print is called it converts the Python object 3 to a string, yet another Python object, appends a linefeed, creating yet another Python object, and prints the string to stdout.

Your recursive function calls do not need variables. Just we were only interested in the result of 1 + 2 your function is only interested in the result of self.subsetsRecur(current, sset[1:]) +self.subsetsRecur(current + [sset[0]], sset[1:])

Are you wondering what happens to all those Python objects that are created? A vast majority of them get tossed in the trash when no longer needed, their storage made available to be reused for new Python objects. The only objects that are not tossed in the trash are those referenced by a variable.