### Question :

Suppose we need to write a function that gives the list of all the subsets of a set. The function and the doctest is given below. And we need to complete the whole definition of the function

```
def subsets(s):
"""Return a list of the subsets of s.
>>> subsets({True, False})
[{False, True}, {False}, {True}, set()]
>>> counts = {x for x in range(10)} # A set comprehension
>>> subs = subsets(counts)
>>> len(subs)
1024
>>> counts in subs
True
>>> len(counts)
10
"""
assert type(s) == set, str(s) + ' is not a set.'
if not s:
return [set()]
element = s.pop()
rest = subsets(s)
s.add(element)
```

It has to not use any built-in function

My approach is to add “element” into rest and return them all, but I am not really familiar how to use set, list in Python.

##
Answer #1:

Look at the powerset() recipe in the itertools docs.

```
from itertools import chain, combinations
def powerset(iterable):
"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
def subsets(s):
return map(set, powerset(s))
```

##
Answer #2:

```
>>> s=set(range(10))
>>> L=list(s)
>>> subs = [{L[j] for j in range(len(L)) if 1<<j&i} for i in range(1,1<<len(L))]
>>> s in subs
True
>>> set() in subs
False
```

##
Answer #3:

```
>>> from itertools import combinations
>>> s=set(range(10))
>>> subs = [set(j) for i in range(len(s)) for j in combinations(s, i+1)]
>>> len(subs)
1023
```

##
Answer #4:

The usual implementation of powerset on `list`

goes something like this:

```
def powerset(elements):
if len(elements) > 0:
head = elements[0]
for tail in powerset(elements[1:]):
yield [head] + tail
yield tail
else:
yield []
```

Just needs a little bit of adaptation to deal with `set`

.

##
Answer #5:

Slightly more efficient (less copying around than in previous answers):

```
# Generate all subsets of the list v of length l.
def subsets(v, l):
return _subsets(v, 0, l, [])
def _subsets(v, k, l, acc):
if l == 0:
return [acc]
else:
r = []
for i in range(k, len(v)):
# Take i-th position and continue with subsets of length l - 1:
r.extend(_subsets(v, i + 1, l - 1, acc + [v[i]]))
return r
```

##
Answer #6:

If you want to get all subsets without using itertools or any other libraries you can do something like this.

```
def generate_subsets(elementList):
"""Generate all subsets of a set"""
combination_count = 2**len(elementList)
for i in range(0, combination_count):
tmp_str = str(bin(i)).replace("0b", "")
tmp_lst = [int(x) for x in tmp_str]
while (len(tmp_lst) < len(elementList)):
tmp_lst = [0] + tmp_lst
subset = list(filter(lambda x : tmp_lst[elementList.index(x)] == 1, elementList))
print(subset)
```

##
Answer #7:

```
>>> from itertools import combinations
>>> s=set([1,2,3])
>>> sum(map(lambda r: list(combinations(s, r)), range(1, len(s)+1)), [])
[(1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
```

produces tuples, but it is close enough for you