Sometimes we have the utility in which we require to find the frequency of elements in the list and the solution to this problem has been discussed many times. But sometimes we come across the task in which we require to find the number of lists that particular elements occur. Let’s discuss certain shorthands in which this can be done.
Method #1 : Using Counter() + set() + list comprehension
The combination of the above functions can be used to perform the task. The Counter function does the grouping, set function extracts the distinct elements as keys of dict and list comprehension check for its list occurrences.
Python3
from collections import Counter
test_list = [[3, 5, 4],
[6, 2, 4],
[1, 3, 6]]
print("The original list : " + str(test_list))
res = dict(Counter(i for sub in test_list for i in set(sub)))
print("The list frequency of elements is : " + str(res))
|
Output : The original list : [[3, 5, 4], [6, 2, 4], [1, 3, 6]]
The list frequency of elements is : {1: 1, 2: 1, 3: 2, 4: 2, 5: 1, 6: 2}
Time Complexity: O(n^2), where n is the total number of tuples in the input “test_list”.
Auxiliary Space: O(n)
Method #2 : Using Counter() + itertools.chain.from_iterable() + map() + set()
The above 4 functionalities can also be combined to achieve this particular task. The set function extracts the dictionary keys formed by the Counter, map function performs the task for all sublists and from_iterable function performs using iterators which is faster than list comprehension.
Python3
from collections import Counter
from itertools import chain
test_list = [[3, 5, 4],
[6, 2, 4],
[1, 3, 6]]
print("The original list : " + str(test_list))
res = dict(Counter(chain.from_iterable(map(set, test_list))))
print("The list frequency of elements is : " + str(res))
|
Output : The original list : [[3, 5, 4], [6, 2, 4], [1, 3, 6]]
The list frequency of elements is : {1: 1, 2: 1, 3: 2, 4: 2, 5: 1, 6: 2}
Method #3: Using python dictionary + get() method
Python dictionary provides a get method which returns the value corresponding to the key and if the key does not exist in the dictionary then it provides functionality to create the key and assign it a default value. We will use this functionality of a dictionary.
Python3
d = {}
test_list = [[3, 5, 4],
[6, 2, 4],
[1, 3, 6]]
for x in test_list:
for i in x:
d[i] = d.get(i,0) + 1
print(f"The original list : {test_list}" )
print(f"The list frequency of elements is : {d}" )
|
Output:
The original list : [[3, 5, 4], [6, 2, 4], [1, 3, 6]]
The list frequency of elements is : {3: 2, 5: 1, 4: 2, 6: 2, 2: 1, 1: 1}Method #4: Using Pandas
In this method we will use a python module named pandas(You can know more about pandas in this article) to find the frequency of the given data, here below is the code for it.
Python3
import pandas as pd
test_list = [3,5,4,3,3,4,5,2]
df1 = pd.Series(test_list).value_counts().sort_index().reset_index().reset_index(drop=True)
df1.columns = ['Element', 'Frequency']
print(f"The original list : {test_list}" )
print(f"The list frequency of elements is :\n {df1.to_string(index=False)}" )
|
Output:
The original list : [3, 5, 4, 3, 3, 4, 5, 2]
The list frequency of elements is :
Element Frequency
2 1
3 3
4 2
5 2
Method#5Using defaultdict and loop:
Step-by-step algorithm:
- Import defaultdict from the collection’s module.
- Initialize the input list test_list
- Create a defaultdict object res with the default value of 0.
- Loop over each sublist in test_list.
- Loop over each element in the sublist.
- Increment the value of the res dictionary at the key corresponding to the current element by 1.
- Convert the res dictionary to a regular dictionary and print the result.
Python3
from collections import defaultdict
test_list = [[3, 5, 4],
[6, 2, 4],
[1, 3, 6]]
print("The original list : " + str(test_list))
res = defaultdict(int)
for sublist in test_list:
for elem in sublist:
res[elem] += 1
print("The list frequency of elements is : " + str(dict(res)))
|
OutputThe original list : [[3, 5, 4], [6, 2, 4], [1, 3, 6]]
The list frequency of elements is : {3: 2, 5: 1, 4: 2, 6: 2, 2: 1, 1: 1} Time complexity: O(n^2), where n is the number of elements in test_list. This is because there are nested loops over the input list.
Auxiliary space: O(n), where n is the number of elements in test_list. This is because a dictionary is used to store the frequency of each element.
Method #6 : Using list(),set(),extend(),count() methods
Approach
- Create an empty dictionary res
- Convert nested list test_list to list x using extend()+for loop
- Create a list y with unique values of x using list(),set() methods
- Initiate a for loop to assign values of y as keys and count of these values in x as values to dictionary res
- Display res
Python3
test_list = [[3, 5, 4],
[6, 2, 4],
[1, 3, 6]]
print("The original list : " + str(test_list))
res = dict()
x=[]
for i in test_list:
x.extend(i)
y=list(set(x))
for i in y:
res[i]=x.count(i)
print("The list frequency of elements is : " + str(res))
|
OutputThe original list : [[3, 5, 4], [6, 2, 4], [1, 3, 6]]
The list frequency of elements is : {1: 1, 2: 1, 3: 2, 4: 2, 5: 1, 6: 2} Time Complexity : O(N) N – length of extended list
Auxiliary Space : O(N) N – length of dictionary res
Method #7 : Using reduce():
Algorithm :
- Import the reduce function from the functools module.
- Initialize a nested list, test_list, with integer elements.
- Print the original nested list.
- Use the reduce() function with a lambda function to flatten the nested list into a flat list.
- The lambda function takes two arguments x and y which represent the accumulator and the current element respectively.
- The lambda function concatenates the two lists x and y using the + operator.
- Use the reduce() function with another lambda function to compute the frequency of each element in the flat list.
- The lambda function takes two arguments x and y which represent the accumulator and the current element respectively.
- The lambda function returns a dictionary x with an updated count of the current element y.
- If the current element y is not in the dictionary, the get() method returns 0.
- The ** syntax is used to unpack the dictionary x and update it with a new key-value pair {y: x.get(y, 0) + 1}.
- Print the resulting dictionary containing the frequency of elements.
Python3
from functools import reduce
test_list = [[3, 5, 4],
[6, 2, 4],
[1, 3, 6]]
print("The original list : " + str(test_list))
flat_list = reduce(lambda x, y: x + y, test_list)
freq_dict = reduce(lambda x, y: {**x, y: x.get(y, 0) + 1}, flat_list, {})
print("The list frequency of elements is : " + str(freq_dict))
|
OutputThe original list : [[3, 5, 4], [6, 2, 4], [1, 3, 6]]
The list frequency of elements is : {3: 2, 5: 1, 4: 2, 6: 2, 2: 1, 1: 1} Time Complexity: O(N*M) where N is the number of sub-lists in the input list and M is the average length of each sub-list. The first reduce() function iterates over each sub-list in the input list and the extend() method inside the lambda function iterates over each element in the sub-list. The second reduce() function also iterates over each element in the flattened list.
Space Complexity: O(NM) where N is the number of sub-lists in the input list and M is the maximum length of each sub-list. The flattened list created by the first reduce() function can be as large as NM. The dictionary created by the second reduce() function will also contain N*M key-value pairs in the worst case.