Python – Dictionary List Values Frequency

Sometimes, while working with Python dictionaries, we can have a problem in which we need to perform the task of computing frequency of all the values in dictionary values lists. This is quite common problem and can have use cases in many domains. Let’s discuss certain ways in which this task can be performed.
 

Input : test_dict = {1: [‘gfg’, ‘CS’, ‘cool’], 2: [‘gfg’, ‘CS’]} 
Output : {‘gfg’: 2, ‘CS’: 2, ‘cool’: 1}

Input : test_dict = {1 : [‘gfg’, ‘CS’]} 
Output : {‘gfg’: 1, ‘CS’: 1} 

Method #1 : Using defaultdict() + loop 
The combination of above functions can be used to solve this problem. In this, we use defaultdict() to initialize the counter for each value and brute force is used to increment the counter in dictionary lists.
 

Time Complexity: O(nm), where n is the total number of keys in the input “test_dict” and m is the total number of elements in all the lists in the dictionary values.

 Space Complexity: O(k), where k is the total number of unique elements in all the lists in the dictionary values.

Method #2 : Using chain.from_iterables() + Counter() 
The combination of above functions can be used to solve this problem. In this, we perform task of Counting using Counter() and the flattening/extraction of values is done using from_iterables().
 

Method #3: Using Counter() + list comprehension

• Import Counter from collections
• Define the original dictionary test_dict
• Use a list comprehension to flatten the values of test_dict into a list of all values
• Use Counter to count the frequency of each value in the flattened list
• Print the resulting dictionary of value frequencies

Values Frequency : {'gfg': 3, 'best': 3, 'geeks': 1, 'CS': 2, 'for': 1, 'test': 1, 'ide': 1, 'success': 1, 'is': 1}

Time complexity: O(n), where n is the total number of values in test_dict.
Auxiliary space: O(n), for the list of all values.

Method #4 : Using values(),list(),set(),extend(),count() methods

Approach

1. Store the values of dictionary test_dict in x(using list(),values() method) which is a nested list
2. Convert nested list to list y  using  extend and for loop
3. Store unique values of y in z using list(),set() methods, create an empty dictionary res
4. Initiate a for loop over list z and assign values of z as keys and the count of those values in y as values to dictionary res
5. Display res

The original dictionary : {1: ['gfg', 'best', 'geeks'], 2: ['gfg', 'CS'], 3: ['best', 'for', 'CS'], 4: ['test', 'ide', 'success'], 5: ['gfg', 'is', 'best']}
Values Frequency : {'test': 1, 'gfg': 3, 'ide': 1, 'best': 3, 'CS': 2, 'is': 1, 'success': 1, 'for': 1, 'geeks': 1}

Time Complexity : O(N) N -length of extended list(y)

Auxiliary Space : O(N) N – length of output dictionary

Method #5 : Using numpy:

Algorithm :

1. Create a dictionary test_dict.
2. Use numpy.hstack() to flatten all the values in the dictionary into a single list named list_values.
3. Use numpy.unique() to count the frequency of each item in the list list_values and return the unique values and their counts in two separate lists named unique and counts.
4. Use dict(zip()) to create a new dictionary frequency_dict where unique and counts are zipped together as key-value pairs.
    
5. Print the frequency dictionary

Output:
The original dictionary : {1: ['gfg', 'best', 'geeks'], 2: ['gfg', 'CS'], 3: ['best', 'for', 'CS'], 4: ['test', 'ide', 'success'], 5: ['gfg', 'is', 'best']}
Values Frequency : {'CS': 2, 'best': 3, 'for': 1, 'geeks': 1, 'gfg': 3, 'ide': 1, 'is': 1, 'success': 1, 'test': 1}

Time Complexity:

Flattening the dictionary values into a single list takes O(n) time, where n is the total number of values in all lists combined.
Counting the frequency of each item in the list takes O(k log k) time, where k is the number of unique items in the list.
Zipping the unique values and their counts as key-value pairs into a new dictionary takes O(k) time.
Therefore, the overall time complexity of the code is O(n + k log k).
Space Complexity:

The space used by the original dictionary test_dict is O(n).
The space used by the list_values list is also O(n).
The space used by the unique and counts lists is O(k).
The space used by the frequency_dict dictionary is also O(k).

Therefore, the overall space complexity of the code is O(n + k).

manjeet_04

Follow

Improve

Article Tags :

• Python
• Python Programs
• Python dictionary-programs

Practice Tags :

• python