Print all sublists of a list in Python

Given a list, print all the sublists of a list.
Examples: 

Input  : list = [1, 2, 3] 
Output : [[], [1], [1, 2], [1, 2, 3], [2], 
         [2, 3], [3]]

Input : [1, 2, 3, 4] 
Output : [[], [1], [1, 2], [1, 2, 3], [1, 2, 3, 4], 
         [2], [2, 3], [2, 3, 4], [3], [3, 4], [4]]

Approach#1: 

The approach will be run two nested loops till the length of the given list. The outer loop i traverse from 0 to the length of the list and the inner loop goes from 0 to i. Need to add 1 to length because the range only goes from 0 to i-1. To get the subarray we can use slicing to get the subarray. 

Step 1: Run a loop till length+1 of the given list.
Step 2: Run another loop from 0 to i.
Step 3: Slice the subarray from j to i. 
Step 4: Append it to a another list to store it 
Step 5: Print it at the end

Below is the Python implementation of the above approach:

Python

# Python program to print all
# sublist from a given list

# function to generate all the sub lists
def sub_lists (l):
    lists = [[]]
    for i in range(len(l) + 1):
        for j in range(i):
            lists.append(l[j: i])
    return lists

# driver code
l1 = [1, 2, 3]
print(sub_lists(l1))

Output

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

Time Complexity: O(n*n)
Auxiliary Space: O(n)

Approach#2: 

The approach will use for loop and combinations function. For loop is used to iterate till the length of list which is helpful for generating a sub-list of variable i^th length. With each iteration combinations function generate the possible combination of list with i^th length. 

Python3

# Python program to print all
# sublist from a given list
from itertools import combinations

# function to generate all the sub lists
def sub_lists (l):
    # initializing empty list
    comb = []

    #Iterating till length of list
    for i in range(len(l)+1):
        # Generating sub list
        comb += [list(j) for j in combinations([1, 2, 3], i)]
    # Returning list
    return comb

# driver code
#Initial list
l1 = [1, 2, 3]

#Print initial list
print("Initial list is : " + str(l1))

# Calling function to generate all sub lists
print("All sub list is : "+ str(sub_lists(l1)))

Output

Initial list is : [1, 2, 3]
All sub list is : [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]

Approach #3:

The recursive approach uses a base case of an empty list being returned and a recursive case of generating sublists, with and without the first element of the list. 
The iteration creates a copy of all the sublists, and then appends each element of the list to each sublist to generate all the sublists. 

Python

def generateSublists(lst):
    # Base case
    if len(lst) == 0:
        return [[]]

    # Recursive case
    sublists = []
    first_element = lst[0]
    rest_list = lst[1:]
    sublists_of_rest = generateSublists(rest_list)
    # Generate sublists including first element
    for sublist in sublists_of_rest:
        sublists.append([first_element] + sublist)
    # Generate sublists excluding first element
    sublists.extend(sublists_of_rest)

    return sublists


# Driver code
l1 = [1, 2, 3]
print(generateSublists(l1))

Output

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

The time complexity of the above code is O(2^n), where n is the length of the input list. This is because at each recursive step, the list is divided into two sublists of equal size. 
The Auxiliary Space is also O(2^n), since at each step the recursive call stack will contain a new sublist for each of the 2^n sublists generated.