Ranking Elements of multiple Lists by their count in Python

python rank list
count elements in list of lists python
count of all elements in list python
how to count the number of lists in a list python
count number of elements in nested list
python count matches in a list
python count occurrences in list
python count frequency in list

I want to rank multiple lists according to their elements how often they appear in each list. Example:

list1 = 1,2,3,4 list2 = 4,5,6,7 list3 = 4,1,8,9

result = 4,1,2,3,4,5,6,7,8 (4 is counted three times, 1 two times and the rest once)

I've tried the following but i need something more intelligent and something i can do with any ammount of lists.

 l = []
 l.append([ 1, 2, 3, 4, 5])
 l.append([ 1, 9, 3, 4, 5])
 l.append([ 1, 10, 8, 4, 5])
 l.append([ 1, 12, 13, 7, 5])
 l.append([ 1, 14, 13, 13, 6])

 x1 = set(l[0]) & set(l[1]) & set(l[2]) & set(l[3])
 x2 = set(l[0]) & set(l[1]) & set(l[2]) & set(l[4])
 x3 = set(l[0]) & set(l[1]) & set(l[3]) & set(l[4])
 x4 = set(l[0]) & set(l[2]) & set(l[3]) & set(l[4])
 x5 = set(l[1]) & set(l[2]) & set(l[3]) & set(l[4])
 set1 = set(x1) | set(x2) | set(x3) | set(x4) | set(x5)

 a1 = list(set(l[0]) & set(l[1]) & set(l[2]) & set(l[3]) & set(l[4]))
 a2 = getDifference(list(set1),a1)
 print a1
 print a2

Now here is the problem... i can do it again and again with a3,a4 and a5 but its too complex then, i need a function for this... But i don't know how... my math got stuck ;)

SOLVED: thanks alot for the discussion. As a newbee i like this system somehow: fast+informative. You helped me all out! Ty

import collections

data = [
  [1, 2, 3, 4, 5],
  [1, 9, 3, 4, 5],
  [1, 10, 8, 4, 5],
  [1, 12, 13, 7, 5],
  [1, 14, 13, 13, 6],

def sorted_by_count(lists):
  counts = collections.defaultdict(int)
  for L in lists:
    for n in L:
      counts[n] += 1

  return [num for num, count in
                 key=lambda k_v: (k_v[1], k_v[0]),

print sorted_by_count(data)

Now let's generalize it (to take any iterable, loosen hashable requirement), allow key and reverse parameters (to match sorted), and rename to freq_sorted:

def freq_sorted(iterable, key=None, reverse=False, include_freq=False):
  """Return a list of items from iterable sorted by frequency.

  If include_freq, (item, freq) is returned instead of item.

  key(item) must be hashable, but items need not be.

  *Higher* frequencies are returned first.  Within the same frequency group,
  items are ordered according to key(item).
  if key is None:
    key = lambda x: x

  key_counts = collections.defaultdict(int)
  items = {}
  for n in iterable:
    k = key(n)
    key_counts[k] += 1
    items.setdefault(k, n)

  if include_freq:
    def get_item(k, c):
      return items[k], c
    def get_item(k, c):
      return items[k]

  return [get_item(k, c) for k, c in
                 key=lambda kc: (-kc[1], kc[0]),


>>> import itertools
>>> print freq_sorted(itertools.chain.from_iterable(data))
[1, 5, 4, 13, 3, 2, 6, 7, 8, 9, 10, 12, 14]
>>> print freq_sorted(itertools.chain.from_iterable(data), include_freq=True)
# (slightly reformatted)
[(1, 5),
 (5, 4),
 (4, 3), (13, 3),
 (3, 2),
 (2, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1), (12, 1), (14, 1)]

Python - Elements frequency count in multiple lists, I want to rank multiple lists according to their elements how often they appear in each list. Example: list1 = 1,2,3,4 list2 = 4,5,6,7 list3 = 4,1,8,9. Count the number of lists containing x. Initialize count to 0, then start a for loop and check if x exists in each list or not. If yes, increment count. filter_none. edit. close. play_arrow. link. brightness_4.

Combining a couple of ideas already posted:

from itertools import chain
from collections import defaultdict

def frequency(*lists):
    counter = defaultdict(int)
    for x in chain(*lists):
        counter[x] += 1
    return [key for (key, value) in 
        sorted(counter.items(), key=lambda kv: (kv[1], kv[0]), reverse=True)]


  1. In Python 2.7, you can use Counter instead of defaultdict(int).
  2. This version takes any number of lists as its argument; the leading asterisk means they'll all be packed into a tuple. If you want to pass in a single list containing all of your lists, omit that leading asterisk.
  3. This breaks if your lists contain an unhashable type.

Creating a list containing the rank of the elements in the original list , Sometimes while working with Python lists we can have a problem in which we need to extract the frequency of elements in list. But this can be added work if we​  Count list elements in Python. Count elements in list. >>> myList=[8, 2, 3, 6, 8]>>> len(myList)5. Count the occurrences of a given item in the list. >>> myList=["a","a","a","b","c","c"]>>> myList.count('a')3. Test if a given value is in the list. >>> myList=[10,20,30,40,50]>>> 25 in myListFalse. See also.

def items_ordered_by_frequency(*lists):

    # get a flat list with all the values
    biglist = []
    for x in lists:
        biglist += x

    # sort it in reverse order by frequency
    return sorted(set(biglist), 
                  key=lambda x: biglist.count(x), 

10 Efficient Ways to Use Python Lists - Better Programming, I believe your solution is O(n2), and we can reduce that to O(nlogn). I'm not well-​versed in python, but this is the general idea: The output is a permutation of the  Count. This method does not return the number of elements in the list. Instead it counts a specific element. As an argument, pass the value of the element we wish to count. Note: Internally count() loops through all the elements and keeps track of the count. It then returns this value.

Try this one:

def rank(*lists):
    d = dict()
    for lst in lists:
        for e in lst:
            if e in d: d[e] += 1
            else: d[e] = 1
    return [j[1] for j in sorted([(d[i],i) for i in d], reverse=True)]

Usage example:

a = [1,2,3,4]
b = [4,5,6,7]
c = [4,1,8,9]

print rank(a,b,c)

You can use any number of lists as input

Sorting HOW TO, The in keyword is used to determine if an element exists in the list. “shallow” copy of a Python list, ranked from the most efficient to the least in Using the Counter library, we can retrieve the number of occurrences of each element. The following code shows an example of iterating over multiple lists,  Python Iterate over multiple lists simultaneously Iterating over single lists, refers to using for loops for iteration over a single element of a single list at a particular step whereas in iterating over multiple lists simultaneously, we refer using for loops for iteration over a single element of multiple lists at a particular step.

You can count the number of appearances of each element (a histogram), then sort by it:

def histogram(enumerable):
  result = {}
  for x in enumerable:
    result.setdefault(x, 0)
    result[x] += 1
  return result

lists = [ [1,2,3,4], [4,5,6,7], ... ]

from itertools import chain

h = histogram(chain(*lists))
ranked = sorted(set(chain(*lists)), key = lambda x : h[x], reverse = True)

Python List Comprehension Tutorial, Python lists have a built-in list.sort() method that modifies the list in-place. parameter to specify a function to be called on each list element prior to making comparisons. The operator module functions allow multiple levels of sorting. priority by counting the number of exclamation marks in a message:. Python list method count() returns count of how many times obj occurs in list. Syntax. Following is the syntax for count() method − list.count(obj) Parameters. obj − This is the object to be counted in the list. Return Value. This method returns count of how many times obj occurs in list. Example. The following example shows the usage of

Counting List Levels and Items at those Levels - Lists-Logic, Lastly, you'll dive into nested list comprehensions to iterate multiple The values that you put in a Python list can be of any data type, even lists  A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

Kendall tau distance, I am trying to count the number of list levels in a list and the number of items on List.Rank will tell you how many levels a list has (its depth). If you are but also the count of items at each level then a recursive function (Python or DS the list levels on the count node, multiple times for the same input list to  There is only one 15 so 15 gets a rank of 6 since 5 elements are ranked. Next element is 25 and it gets a rank of 7. Input : 1, 2, 5, 2, 1, 60, 3 Output : 1.5, 3.5, 6.0, 3.5, 1.5, 7.0, 5.0. Explanation for first input : Method I (Simple). Consider that there are no repeated elements.

Lists and loops, The Kendall tau rank distance is a metric that counts the number of pairwise disagreements between two ranking lists. The larger the distance, the more  Adds an element at the end of the list: clear() Removes all the elements from the list: copy() Returns a copy of the list: count() Returns the number of elements with the specified value: extend() Add the elements of a list (or any iterable), to the end of the current list: index() Returns the index of the first element with the specified value

  • i can't decide which solution is the fastest. 2 for's is = O(n**2) but howto make it faster.. :/
  • Beats me. Yours is the only one (except mine, but I copied yours) that applies the second sort order, which is a nice touch.
  • Two for loops is not what makes some of these answers O(n^2), which this one isn't. It's calling count(x) on each item in the chained list that makes them O(n^2).
  • proxylittle: n being the sum of the lengths of each list in lists means my nested for loops are still only O(n), or "each item from the original data is only processed once" (gross simplification, not strictly true, but O(2n) is still O(n)). Also the sorting is O(m log m) and the final list comprehension is O(m) (where m is the number of unique items), so the whole function is O(n log n) (m cannot be greater than n). That said, the "fastest" solution still depends on exactly how it's implemented and the characteristics of the input, but algorithmic complexity is how you generalize that.
  • it broke for me... true!
  • Good ol' O(n**2), ah, how I've missed you.
  • He didn't say he wanted it lightening fast. This was just meant to be simple.
  • True, but the problem with O(n^2) is that the leap from "not lightning fast" to "unusably slow" is really easy to make.
  • ah.. well... faster is better ofc.
  • You're iterating over the chain of lists twice here. If you sort the histogram, you only need to iterate over it once. (Also, you don't need to build a set, because you already did.)
  • @Robert - you're correct, but efficiency isn't the only concern. I find using the histogram's keys confusing - of course if this was a bottleneck then sure, I wouldn't hesitate.