Python | Count number of items in a dictionary value that is a list

Last Updated : 27 Apr, 2023

In Python, dictionary is a collection which is unordered, changeable and indexed. Dictionaries are written with curly brackets, and they have keys and values. It is used to hash a particular key. A dictionary has multiple key:value pairs. There can be multiple pairs where value corresponding to a key is a list. To check that the value is a list or not we use the isinstance() method which is inbuilt in Python. isinstance() method takes two parameters:

object - object to be checked
classinfo - class, type, or tuple of classes and types

It return a boolean whether the object is an instance of the given class or not. Let's discuss different methods to count number of items in a dictionary value that is a list. Method #1 Using in operator

Python3

# Python program to count number of items
# in a dictionary value that is a list.
def main():

    # defining the dictionary
    d = {'A' : [1, 2, 3, 4, 5, 6, 7, 8, 9],
        'B' : 34,
        'C' : 12,
        'D' : [7, 8, 9, 6, 4] }

    # using the in operator
    count = 0
    for x in d:
        if isinstance(d[x], list):
            count += len(d[x])
    print(count)

# Calling Main    
if __name__ == '__main__':
    main()

Output

Time Complexity: O(n), where n is the number of key-value pairs in the dictionary d. This is because the code iterates through each key-value pair in the dictionary using the for loop and for each key-value pair, it checks if the value is a list using the isinstance() function. If the value is a list, it increments the count by the length of the list. Finally, it prints the count.
Auxiliary Space: O(n), because it only uses a fixed amount of memory to store the dictionary d, the count, and the temporary variables x. It does not use any data structures that grow in proportion to the size of the input.

Method #2: Using list comprehension

Python3

# Python program to count number of items
# in a dictionary value that is a list.
def main():

    # defining the dictionary
    d = {'A' : [1, 2, 3, 4, 5, 6, 7, 8, 9],
        'B' : 34,
        'C' : 12,
        'D' : [7, 8, 9, 6, 4] }

    # using list comprehension
    print(sum([len(d[x]) for x in d if isinstance(d[x], list)]))
    
if __name__ == '__main__':
    main()

Output

Time complexity: O(n), where n is the number of key-value pairs in the dictionary.
Auxiliary space: O(n), to store the keys and values in dictionary.

Method #3: Using dict.items()

Python3

# Python program to count number of items
# in a dictionary value that is a list.
def main():

    # defining the dictionary
    d = { 'A' : [1, 2, 3, 4, 5, 6, 7, 8, 9],
        'B' : 34,
        'C' : 12,
        'D' : [7, 8, 9, 6, 4] }

    # using dict.items()
    count = 0
    for key, value in d.items():
        if isinstance(value, list):
              count += len(value)
    print(count)
    
if __name__ == '__main__':
    main()

Output

Method #4: Using enumerate()

Python3

# Python program to count number of items
# in a dictionary value that is a list.
def main():

    # defining the dictionary
    d = {'A' : [1, 2, 3, 4, 5, 6, 7, 8, 9],
        'B' : 34,
        'C' : 12,
        'D' : [7, 8, 9, 6, 4] }

    # using enumerate()
    count = 0
    for x in enumerate(d.items()):

        # enumerate function returns a tuple in the form
        # (index, (key, value)) it is a nested tuple
        # for accessing the value we do indexing x[1][1]
        if isinstance(x[1][1], list):
            count += len(x[1][1])
    print(count)

if __name__ == '__main__':
    main()

Output

Method#5: Using values(),find() and type().

Python3

# Python program to count number of items
# in a dictionary value that is a list.
def main():

    # defining the dictionary
    d = {'A' : [1, 2, 3, 4, 5, 6, 7, 8, 9],
        'B' : 34,
        'C' : 12,
        'D' : [7, 8, 9, 6, 4] }
    # values() - to fetch values of dictionary
    count = 0
    
    for x in list(d.values()):
      
        # type() - returns type of a variable
        type1=str(type(x))
        
        # find() - returns position of a specified value if found else returns -1
        if(type1.find('list')!=-1):
            count+=len(x)
            
    print(count)

if __name__ == '__main__':
    main()

Output

Method #6: Using Recursive method.

This function takes a dictionary d as its input, and recursively searches through all the values in the dictionary. If a value is a list, it adds the length of the list to the count. If a value is another dictionary, it calls the count_list_items function recursively on that dictionary and adds the result to the count.

Python3

def count_list_items(d):
    count = 0
    for v in d.values():
        if isinstance(v, list):
            count += len(v)
        elif isinstance(v, dict):
            count += count_list_items(v)
    return count
def main():

    # defining the dictionary
    d = {'A' : [1, 2, 3, 4, 5, 6, 7, 8, 9],
        'B' : 34,
        'C' : 12,
        'D' : [7, 8, 9, 6, 4] }

    count=count_list_items(d)
    print(count)

if __name__ == '__main__':
    main()

Output

The time complexity of this function is O(N), where N is the total number of elements in all the lists in the dictionary. This is because the function needs to examine each element in each list exactly once.

The space complexity of this function is also O(N), where N is the total number of elements in all the lists in the dictionary. This is because the function needs to keep track of the count, as well as the call stack for each level of recursion.