suppose your dictionary is named d and you want a count of the values:

from collections import Counter
d = {1: "dog", 2: "cat", 3: "dog", 4: "elephant"}
counts = Counter(d.values())

Now you can use the counts Counter:

# Values in the original dictionary
counts['dog'] # 2
counts['elephant'] # 1
# Value not in the original dictionary
counts['fish'] # 0

If you must use custom code and classes for this instead of the standard library, I think your error is here:

result.add((self.count(i), self.items[i]))

What you may want is:

animal_name = self.items[i] #?
result.add((self.count(animal_name), animal_name))

Otherwise you may want to share with us what is in self.items...

Instead of using a comprehension, just apply a Counter to the values of your dictionary.

>>> from collections import Counter
>>> d = {0: 'Succeeded', 1: 'Succeeded', 2: 'Failed', 3: 'Failed', 4: 'Succeeded'}
>>> Counter(d.values())
Counter({'Failed': 2, 'Succeeded': 3})

General Tip

Dictionaries with consecutive integer keys are a waste of memory. You could just use a list

my_list = ['Succeeded', 'Succeeded', 'Failed', 'Failed', 'Succeeded']

into which you can index with integers 0, 1, 2, ... like you would with your original dictionary. The list takes less memory and values can be found without hashing keys.

In this case, Counter(my_list) would construct the dictionary you desire.

WARNING BAD CODE BELOW

You could but not should write a comprehension as follows

>>> vals = list(d.values())
>>> {v:vals.count(v) for v in vals}
{'Failed': 2, 'Succeeded': 3}

but I strongly advise against using this comprehension because as opposed to the O(n) Counter solution, it has quadratic time complexity. For each value in vals, vals is iterated in order to count the value.

You should use collections.Counter:

>>> from collections import Counter
>>> d = {'a':3, 'b':9, 'c':88, 'd': 3}
>>> Counter(d.values()).most_common()
[(3, 2), (88, 1), (9, 1)]

Since you want to count the number of times each language appears in each position in a ranking, we can use dict.setdefault (which allows to set a default value if a key doesn't exist in a dict yet) to set a default dictionary of zero values to each language rank as we iterate over the list and walk the dicts.

The idea is to initialize a dictionary that maps language names to 0s (using dict.fromkeys) and in every iteration, if a language exists in some position, then add the number corresponding to the language by one in the inner dictionary.

out = {}
for d in lst:
    for num, language in d.items():
        out.setdefault(num, dict.fromkeys(lst[0].values(), 0))
        out[num][language] += 1

Output:

{'language1': {'C++': 1, 'PHP': 1, 'Python': 2, 'Java': 1},
 'language2': {'C++': 2, 'PHP': 1, 'Python': 1, 'Java': 1},
 'language3': {'C++': 2, 'PHP': 0, 'Python': 2, 'Java': 1},
 'language4': {'C++': 0, 'PHP': 2, 'Python': 1, 'Java': 2}}

That's actually a pretty interesting way of creating a "Count" feature. The issue is that your code counts items in lists, so passing a dictionary to it won't work. Instead, you should pass the values from your dic.items(). If we use what you have:

for k, v in dic.items():
    D = defaultdict(list)
    for i, item in enumerate(v):
        D[item].append(i)
    D = {k: v for k, v in D.items()}
    print(k, D)

Also, take a look at collections.Counter which is a standard library implementation of Count.

from collections import Counter
for k, v in dic.items():
    print(k, Counter(v))

Use itertools.chain to flat your lists of list (or a nested comprehension)

from itertools import chain
frequency_counter = Counter(chain(*[lst for lst in list_chosen_each_round.values()]))

# OR

frequency_counter = Counter(item for lst in list_chosen_each_round.values()
                            for item in lst)

Output:

>>> frequency_counter
Counter({'1': 2,
         '28': 2,
         '11': 2,
         '26': 1,
         '20': 1,
         '14': 1,
         '23': 1,
         '4': 1,
         '17': 1,
         '29': 1,
         '21': 1,
         '8': 1,
         '9': 1,
         '3': 1,
         '27': 1})

If order matters, you have to handle the counter manually:

frequency_counter = {}
for lst in list_chosen_each_round.values():
    for item in lst:
        frequency_counter[item] = frequency_counter.get(item, 0) + 1

Output:

>>> frequency_counter
{'1': 2,
 '26': 1,
 '20': 1,
 '14': 1,
 '28': 2,
 '23': 1,
 '4': 1,
 '17': 1,
 '29': 1,
 '21': 1,
 '8': 1,
 '11': 2,
 '9': 1,
 '3': 1,
 '27': 1}