Python | Program to count number of lists in a list of lists

Given a list of lists, write a Python program to count the number of lists contained within the list of lists. 

Examples:

Input :  [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
Output : 3
 
Input : [[1], ['Bob'], ['Delhi'], ['x', 'y']]
Output : 4

Method #1 : Using len() 

# Python3 program to Count number
# of lists in a list of lists


def countList(lst):
    return len(lst)


# Driver code
lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
print(countList(lst))

3

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

Method #2: Using type() 

Use a for loop and in every iteration to check if the type of the current item is a list or not, and accordingly increment 'count' variable. This method has a benefit over approach #1, as it works well for a list of heterogeneous elements. 

# Python3 program to Count number
# of lists in a list of lists


def countList(lst):
    count = 0
    for el in lst:
        if type(el) == type([]):
            count += 1

    return count


# Driver code
lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
print(countList(lst))

3

Time complexity: O(n), where n is the number of elements in the list.
Auxiliary space: O(1), as we are only using a single variable (count) to store the count of lists.

A one-liner alternative approach for the above code is given below: 

def countList(lst):
    return sum(type(el)== type([]) for el in lst)

Method #3 : Using isinstance() method 

# Python3 program to Count number 
# of lists in a list of lists

def countList(lst):
    return sum(isinstance(i, list) for i in lst)
    
# Driver code
lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
print(countList(lst))

3

Time complexity: O(n), where n is the size of the set s.
Auxiliary space: O(n), as we are creating a list x with n elements, where n is the size of the set s.

Method#4: Using the list comprehension

lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
x=[i for i in lst]
print(len(x))

3

Time complexity: O(n), where n is the total number of elements in the list of lists.
Auxiliary space: O(n)

Method #5: Using enumerate function 

lst = ["[1, 2, 3]", "[4, 5]", "[6, 7, 8, 9]"]
x=[list(i) for i in enumerate(lst)]
print(len(x))

3

Time complexity: O(n), where n is length of list.
Auxiliary Space: O(n), where n is length of list.

Method #6: Using lambda function

lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
x=list(filter(lambda i: (i),lst))
print(len(x))

3

The time complexity of this code is O(n*m), where n is the number of sublists in the list and m is the average length of the sublists.

The auxiliary space required by this code is also O(n*m), since the filter function creates a new list that contains the same elements as the original list.

Method #7: Using map()

lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
x=list(map(str,lst) )
print(len(x))

3

Method #8: Using eval() 

lst = ["[1, 2, 3]", "[4, 5]", "[6, 7, 8, 9]"]
x=list(map(eval,lst) )
print(len(x))

3

Method #9 : Using recursion

This approach involves reducing the length of the list by 1 at each recursive step and increasing the count by 1 if the first element of the list is a list. The function returns 0 when the list is empty.

def count_lists(lst):
  if lst == []:
    return 0
  return 1 + count_lists(lst[1:])

lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
print(count_lists(lst))
#This code is contributed by Edula Vinay Kumar Reddy

3

Time complexity: O(n), where n is the total number of elements in the list of lists. This is because the function processes each element of the list exactly once.
Auxiliary space: O(n) as well, since the maximum depth of the recursion tree is n in the worst case. For example, if the list of lists is a list of n single-element lists, the recursion tree will have a maximum depth of n. At each level of the tree, a new frame is added to the call stack, which takes up space in memory.

Method #10: Using ast.literal_eval()

Step-by-step approach:

• Import the ast module.
• Define the list of strings, lst.
• Create an empty list, num_list, to store the converted lists.
• Loop through each string in lst.
• Use ast.literal_eval() to convert the string to a list.
• Append the resulting list to num_list.
• Calculate the length of num_list using len().
• Print the length of num_list.

import ast

lst = ["[1, 2, 3]", "[4, 5]", "[6, 7, 8, 9]"]
num_list = []

for s in lst:
    num_list.append(ast.literal_eval(s))

print(len(num_list))

3

Time complexity: O(n), where n is the length of lst. This is because we loop through each string in lst and apply ast.literal_eval() once for each string.
Auxiliary space: O(n), where n is the length of lst. This is because we create a list of the converted lists, which takes up space in memory.

Method #11: Using functools.reduce()

Step-by-step approach:

• Initialize a list of lists. 
• Use reduce method on the list. 
• reduce method takes a function, list, and initial value as parameters. 
• reduce iterate over each item of the list and apply a function to it and return value.
• Function checks are an item an instance of the list or not, if it is then count 1 to the initial value else do nothing. 

# Python3 program to Count number
# of lists in a list of lists
from functools import reduce 


# Function which count the number of list in list
def countList(lst):
    return reduce(lambda a, b : a + 1 if isinstance(b, list) else a, lst, 0)
    
# Driver code
lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
print(countList(lst))

3

Time complexity: O(N), where N is the length of the list. 
Auxiliary space: O(1), No extra space is used.