අයිතමයක් ලබා දී ඇති විට, පයිතන් හි ලැයිස්තුවක එහි සිදුවීම් ගණනය කරන්නේ කෙසේද?

ඔබට අවශ්‍ය වන්නේ එක් අයිතමයක් පමණක් නම්, countක්‍රමය භාවිතා කරන්න :

>>> [1, 2, 3, 4, 1, 4, 1].count(1)
3

ඔබට බහු අයිතම ගණන් කිරීමට අවශ්‍ය නම් මෙය භාවිතා නොකරන්න . ලූපයකින් ඇමතීම countසඳහා සෑම countඇමතුමක් සඳහාම වෙන වෙනම අවසරයක් අවශ්‍ය වන අතර එය කාර්ය සාධනය සඳහා විනාශකාරී විය හැකිය. ඔබට සියලු අයිතම ගණන් කිරීමට අවශ්‍ය නම්, හෝ බහුවිධ අයිතම පවා Counter, අනෙක් පිළිතුරු වල විස්තර කර ඇති පරිදි භාවිතා කරන්න .

Counterඔබ පයිතන් 2.7 හෝ 3.x භාවිතා කරන්නේ නම් භාවිතා කරන්න , ඔබට එක් එක් මූලද්‍රව්‍යය සඳහා සිදුවීම් ගණන අවශ්‍ය වේ:

>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> Counter(z)
Counter({'blue': 3, 'red': 2, 'yellow': 1})

ලැයිස්තුවක එක් අයිතමයක සිදුවීම් ගණනය කිරීම

ඔබට භාවිතා කළ හැකි එක් ලැයිස්තු අයිතමයක සිදුවීම් ගණනය කිරීම සඳහා count()

>>> l = ["a","b","b"]
>>> l.count("a")
1
>>> l.count("b")
2

ලැයිස්තුවක ඇති සියළුම අයිතමයන්ගේ සිදුවීම් ගණනය කිරීම ලැයිස්තුවක් " ගණනය කිරීම" හෝ ගණනය කිරීමේ කවුන්ටරයක් ​​සෑදීම ලෙසද හැඳින්වේ.

සියලුම අයිතම ගණන් කිරීම සමඟ ගණනය කිරීම ()

lඑක් අයිතමයක සිදුවීම් ගණනය කිරීම සඳහා ලැයිස්තු අවබෝධය සහ count()ක්‍රමය භාවිතා කළ හැකිය

[[x,l.count(x)] for x in set(l)]

(හෝ ඒ හා සමානව ශබ්දකෝෂයක් සමඟ dict((x,l.count(x)) for x in set(l)))

උදාහරණයක්:

>>> l = ["a","b","b"]
>>> [[x,l.count(x)] for x in set(l)]
[['a', 1], ['b', 2]]
>>> dict((x,l.count(x)) for x in set(l))
{'a': 1, 'b': 2}

කවුන්ටරය () සමඟ සියලු අයිතම ගණන් කිරීම

විකල්පයක් ලෙස, පුස්තකාලයෙන් වේගවත් Counterපන්තියක් තිබේcollections

Counter(l)

උදාහරණයක්:

>>> l = ["a","b","b"]
>>> from collections import Counter
>>> Counter(l)
Counter({'b': 2, 'a': 1})

කවුන්ටරය කොතරම් වේගවත්ද?

Counterලැයිස්තු ගණනය කිරීම සඳහා කොතරම් වේගවත්දැයි මම පරීක්ෂා කළෙමි . මම ක්‍රම දෙකම අත්හදා බැලුවේ අගයන් කිහිපයක් සමඟ වන nඅතර එය Counterආසන්න වශයෙන් 2 ක නියත සාධකයක් මඟින් වේගවත් බව පෙනේ .

මෙන්න මම භාවිතා කළ පිටපත:

from __future__ import print_function
import timeit

t1=timeit.Timer('Counter(l)', \
                'import random;import string;from collections import Counter;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]'
                )

t2=timeit.Timer('[[x,l.count(x)] for x in set(l)]',
                'import random;import string;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]'
                )

print("Counter(): ", t1.repeat(repeat=3,number=10000))
print("count():   ", t2.repeat(repeat=3,number=10000)

සහ ප්‍රතිදානය:

Counter():  [0.46062711701961234, 0.4022796869976446, 0.3974247490405105]
count():    [7.779430688009597, 7.962715800967999, 8.420845870045014]

ශබ්දකෝෂයක එක් එක් අයිතමයේ සිදුවීම් ගණන ලබා ගැනීමට තවත් ක්‍රමයක්:

dict((i, a.count(i)) for i in a)

list.count(x)xලැයිස්තුවක් තුළ දිස්වන වාර ගණන නැවත ලබා දෙයි

බලන්න: http://docs.python.org/tutorial/datastructures.html#more-on-lists

අයිතමයක් ලබා දී ඇති විට, පයිතන් හි ලැයිස්තුවක එහි සිදුවීම් ගණනය කරන්නේ කෙසේද?

මෙන්න උදාහරණ ලැයිස්තුවක්:

>>> l = list('aaaaabbbbcccdde')
>>> l
['a', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'e']

list.count

මෙම තියෙනවා list.countක්රමය

>>> l.count('b')
4

ඕනෑම ලැයිස්තුවක් සඳහා මෙය හොඳින් ක්‍රියාත්මක වේ. ටුපල්වරුන්ට මෙම ක්‍රමය ද ඇත:

>>> t = tuple('aabbbffffff')
>>> t
('a', 'a', 'b', 'b', 'b', 'f', 'f', 'f', 'f', 'f', 'f')
>>> t.count('f')
6

collections.Counter

ඊට පස්සේ එකතු කිරීම් තියෙනවා. ලැයිස්තුවක් පමණක් නොව, ඔබට ඕනෑම නැවත කළ හැකි දේ කවුන්ටරයකට දැමිය හැකි අතර, කවුන්ටරය මූලද්‍රව්‍යයන්ගේ ගණන් වල දත්ත ව්‍යුහයක් රඳවා ගනු ඇත.

භාවිතය:

>>> from collections import Counter
>>> c = Counter(l)
>>> c['b']
4

කවුන්ටර පදනම් වී ඇත්තේ පයිතන් ශබ්දකෝෂ මත ය, ඒවායේ යතුරු මූලද්‍රව්‍ය වේ, එබැවින් යතුරු හැෂ් කළ හැකි ය. ඒවා මූලික වශයෙන් අතිරික්ත මූලද්‍රව්‍ය ඒවාට ඇතුළු වීමට ඉඩ දෙන කට්ටල වැනි ය.

තවදුරටත් භාවිතය collections.Counter

ඔබේ කවුන්ටරයෙන් නැවත සැකසීම් සමඟ එකතු කිරීම හෝ අඩු කිරීම කළ හැකිය:

>>> c.update(list('bbb'))
>>> c['b']
7
>>> c.subtract(list('bbb'))
>>> c['b']
4

තවද ඔබට කවුන්ටරය සමඟ බහු-කට්ටල මෙහෙයුම් කළ හැකිය:

>>> c2 = Counter(list('aabbxyz'))
>>> c - c2                   # set difference
Counter({'a': 3, 'c': 3, 'b': 2, 'd': 2, 'e': 1})
>>> c + c2                   # addition of all elements
Counter({'a': 7, 'b': 6, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1})
>>> c | c2                   # set union
Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1})
>>> c & c2                   # set intersection
Counter({'a': 2, 'b': 2})

පැන්ඩා නැත්තේ ඇයි?

තවත් පිළිතුරක් යෝජනා කරන්නේ:

පැන්ඩා භාවිතා නොකරන්නේ ඇයි?

පැන්ඩස් යනු පොදු පුස්තකාලයකි, නමුත් එය සම්මත පුස්තකාලයේ නොමැත. අවශ්‍යතාවයක් ලෙස එය එකතු කිරීම සුළුපටු නොවේ.

ලැයිස්තු වස්තුව තුළ මෙන්ම සම්මත පුස්තකාලයේද මෙම භාවිතය සඳහා බිල්ඩින් විසඳුම් තිබේ.

ඔබේ ව්‍යාපෘතියට දැනටමත් පැන්ඩා අවශ්‍ය නොවේ නම්, මෙම ක්‍රියාකාරීත්වය සඳහා පමණක් අවශ්‍යතාවයක් බවට පත් කිරීම මෝඩකමකි.

මම යෝජනා කළ සියලු විසඳුම් (සහ නව ඒවා කිහිපයක්) perfplot (මගේ කුඩා ව්‍යාපෘතියක් ) සමඟ සංසන්දනය කර ඇත්තෙමි .

එක් අයිතමයක් ගණන් කිරීම

ප්‍රමාණවත් තරම් අරා සඳහා, එය හැරෙනවා

numpy.sum(numpy.array(a) == 1) 

අනෙක් විසඳුම් වලට වඩා තරමක් වේගවත් වේ.

සියලුම අයිතම ගණන් කිරීම

කලින් ස්ථාපිත කළ පරිදි ,

numpy.bincount(a)

ඔබට අවශ්‍ය දේ.

බිම් කොටස් ප්‍රතිනිෂ්පාදනය කිරීමේ කේතය:

from collections import Counter
from collections import defaultdict
import numpy
import operator
import pandas
import perfplot


def counter(a):
    return Counter(a)


def count(a):
    return dict((i, a.count(i)) for i in set(a))


def bincount(a):
    return numpy.bincount(a)


def pandas_value_counts(a):
    return pandas.Series(a).value_counts()


def occur_dict(a):
    d = {}
    for i in a:
        if i in d:
            d[i] = d[i]+1
        else:
            d[i] = 1
    return d


def count_unsorted_list_items(items):
    counts = defaultdict(int)
    for item in items:
        counts[item] += 1
    return dict(counts)


def operator_countof(a):
    return dict((i, operator.countOf(a, i)) for i in set(a))


perfplot.show(
    setup=lambda n: list(numpy.random.randint(0, 100, n)),
    n_range=[2**k for k in range(20)],
    kernels=[
        counter, count, bincount, pandas_value_counts, occur_dict,
        count_unsorted_list_items, operator_countof
        ],
    equality_check=None,
    logx=True,
    logy=True,
    )

2.

from collections import Counter
from collections import defaultdict
import numpy
import operator
import pandas
import perfplot


def counter(a):
    return Counter(a)


def count(a):
    return dict((i, a.count(i)) for i in set(a))


def bincount(a):
    return numpy.bincount(a)


def pandas_value_counts(a):
    return pandas.Series(a).value_counts()


def occur_dict(a):
    d = {}
    for i in a:
        if i in d:
            d[i] = d[i]+1
        else:
            d[i] = 1
    return d


def count_unsorted_list_items(items):
    counts = defaultdict(int)
    for item in items:
        counts[item] += 1
    return dict(counts)


def operator_countof(a):
    return dict((i, operator.countOf(a, i)) for i in set(a))


perfplot.show(
    setup=lambda n: list(numpy.random.randint(0, 100, n)),
    n_range=[2**k for k in range(20)],
    kernels=[
        counter, count, bincount, pandas_value_counts, occur_dict,
        count_unsorted_list_items, operator_countof
        ],
    equality_check=None,
    logx=True,
    logy=True,
    )

ඔබට අවශ්ය නම් එකවර සියලු වටිනාකම් ගණන් ඔබ numpy අරා භාවිතා කරමින් ඉතා වේගවත් එය කරන්න පුළුවන් සහ bincountපහත සඳහන් පරිදි

import numpy as np
a = np.array([1, 2, 3, 4, 1, 4, 1])
np.bincount(a)

එය ලබා දෙයි

>>> array([0, 3, 1, 1, 2])

ඔබට භාවිතා කළ හැකි නම් pandas, value_countsගලවා ගැනීම සඳහා තිබේ.

>>> import pandas as pd
>>> a = [1, 2, 3, 4, 1, 4, 1]
>>> pd.Series(a).value_counts()
1    3
4    2
3    1
2    1
dtype: int64

සංඛ්‍යාතය මත පදනම්ව එය ස්වයංක්‍රීයව ප්‍රති result ලය වර්ග කරයි.

ප්‍රති result ලය ලැයිස්තුවේ ලැයිස්තුවක් වීමට ඔබට අවශ්‍ය නම්, පහත පරිදි කරන්න

>>> pd.Series(a).value_counts().reset_index().values.tolist()
[[1, 3], [4, 2], [3, 1], [2, 1]]

පැන්ඩා භාවිතා නොකරන්නේ ඇයි?

import pandas as pd

l = ['a', 'b', 'c', 'd', 'a', 'd', 'a']

# converting the list to a Series and counting the values
my_count = pd.Series(l).value_counts()
my_count

ප්‍රතිදානය:

a    3
d    2
b    1
c    1
dtype: int64

ඔබ කිසියම් මූලද්‍රව්‍යයක ගණනය කිරීමක් සොයන්නේ නම්, a , උත්සාහ කරන්න:

my_count['a']

ප්‍රතිදානය:

3

මට අද මෙම ගැටලුව ඇති අතර SO පරීක්ෂා කිරීමට පෙර මගේම විසඳුම සකස් කළෙමි. මෙය:

dict((i,a.count(i)) for i in a)

විශාල ලැයිස්තු සඳහා සැබවින්ම මන්දගාමී වේ. මගේ විසඳුම

def occurDict(items):
    d = {}
    for i in items:
        if i in d:
            d[i] = d[i]+1
        else:
            d[i] = 1
return d

ඇත්ත වශයෙන්ම කවුන්ටර විසඳුමට වඩා ටිකක් වේගවත් වේ, අවම වශයෙන් පයිතන් 2.7 සඳහා.

# Python >= 2.6 (defaultdict) && < 2.7 (Counter, OrderedDict)
from collections import defaultdict
def count_unsorted_list_items(items):
    """
    :param items: iterable of hashable items to count
    :type items: iterable

    :returns: dict of counts like Py2.7 Counter
    :rtype: dict
    """
    counts = defaultdict(int)
    for item in items:
        counts[item] += 1
    return dict(counts)


# Python >= 2.2 (generators)
def count_sorted_list_items(items):
    """
    :param items: sorted iterable of items to count
    :type items: sorted iterable

    :returns: generator of (item, count) tuples
    :rtype: generator
    """
    if not items:
        return
    elif len(items) == 1:
        yield (items[0], 1)
        return
    prev_item = items[0]
    count = 1
    for item in items[1:]:
        if prev_item == item:
            count += 1
        else:
            yield (prev_item, count)
            count = 1
            prev_item = item
    yield (item, count)
    return


import unittest
class TestListCounters(unittest.TestCase):
    def test_count_unsorted_list_items(self):
        D = (
            ([], []),
            ([2], [(2,1)]),
            ([2,2], [(2,2)]),
            ([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]),
            )
        for inp, exp_outp in D:
            counts = count_unsorted_list_items(inp) 
            print inp, exp_outp, counts
            self.assertEqual(counts, dict( exp_outp ))

        inp, exp_outp = UNSORTED_WIN = ([2,2,4,2], [(2,3), (4,1)])
        self.assertEqual(dict( exp_outp ), count_unsorted_list_items(inp) )


    def test_count_sorted_list_items(self):
        D = (
            ([], []),
            ([2], [(2,1)]),
            ([2,2], [(2,2)]),
            ([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]),
            )
        for inp, exp_outp in D:
            counts = list( count_sorted_list_items(inp) )
            print inp, exp_outp, counts
            self.assertEqual(counts, exp_outp)

        inp, exp_outp = UNSORTED_FAIL = ([2,2,4,2], [(2,3), (4,1)])
        self.assertEqual(exp_outp, list( count_sorted_list_items(inp) ))
        # ... [(2,2), (4,1), (2,1)]

විසඳුම් තුන පහත දැක්වේ:

වේගවත්ම වන්නේ for for loop එකක් භාවිතා කර එය Dict එකක ගබඩා කිරීමයි.

import time
from collections import Counter


def countElement(a):
    g = {}
    for i in a:
        if i in g: 
            g[i] +=1
        else: 
            g[i] =1
    return g


z = [1,1,1,1,2,2,2,2,3,3,4,5,5,234,23,3,12,3,123,12,31,23,13,2,4,23,42,42,34,234,23,42,34,23,423,42,34,23,423,4,234,23,42,34,23,4,23,423,4,23,4]


#Solution 1 - Faster
st = time.monotonic()
for i in range(1000000):
    b = countElement(z)
et = time.monotonic()
print(b)
print('Simple for loop and storing it in dict - Duration: {}'.format(et - st))

#Solution 2 - Fast
st = time.monotonic()
for i in range(1000000):
    a = Counter(z)
et = time.monotonic()
print (a)
print('Using collections.Counter - Duration: {}'.format(et - st))

#Solution 3 - Slow
st = time.monotonic()
for i in range(1000000):
    g = dict([(i, z.count(i)) for i in set(z)])
et = time.monotonic()
print(g)
print('Using list comprehension - Duration: {}'.format(et - st))

ප්‍රති ult ලය

#Solution 1 - Faster

{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 234: 3, 23: 10, 12: 2, 123: 1, 31: 1, 13: 1, 42: 5, 34: 4, 423: 3}
Simple for loop and storing it in dict - Duration: 12.032000000000153

#Solution 2 - Fast

Counter({23: 10, 4: 6, 2: 5, 42: 5, 1: 4, 3: 4, 34: 4, 234: 3, 423: 3, 5: 2, 12: 2, 123: 1, 31: 1, 13: 1})
Using collections.Counter - Duration: 15.889999999999418

#Solution 3 - Slow

{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 34: 4, 423: 3, 234: 3, 42: 5, 12: 2, 13: 1, 23: 10, 123: 1, 31: 1}
Using list comprehension - Duration: 33.0

සමඟ ඇති සියලුම මූලද්‍රව්‍ය ගණන itertools.groupby()

ලැයිස්තුවේ ඇති සියලුම අංග ගණනය කිරීම සඳහා ඇන්ටොහර්ගේ හැකියාව විය හැකිය itertools.groupby().

"අනුපිටපත්" ගණන් සමඟ

from itertools import groupby

L = ['a', 'a', 'a', 't', 'q', 'a', 'd', 'a', 'd', 'c']  # Input list

counts = [(i, len(list(c))) for i,c in groupby(L)]      # Create value-count pairs as list of tuples 
print(counts)

ප්‍රතිලාභ

[('a', 3), ('t', 1), ('q', 1), ('a', 1), ('d', 1), ('a', 1), ('d', 1), ('c', 1)]

එය aපළමු කණ්ඩායම ලෙස පළමු තිදෙනා ඒකාබද්ධ කළ ආකාරය සැලකිල්ලට ගන්න , අනෙක් කණ්ඩායම් aලැයිස්තුවේ තවත් පහළට පැමිණේ. මෙය සිදුවන්නේ ආදාන ලැයිස්තුව Lවර්ග කර නොමැති නිසාය. කණ්ඩායම් ඇත්ත වශයෙන්ම වෙනම විය යුතු නම් මෙය සමහර විට වාසියක් විය හැකිය.

අද්විතීය ගණන් සමඟ

අද්විතීය කණ්ඩායම් ගණනය කිරීම් අවශ්‍ය නම්, ආදාන ලැයිස්තුව වර්ග කරන්න:

counts = [(i, len(list(c))) for i,c in groupby(sorted(L))]
print(counts)

ප්‍රතිලාභ

[('a', 5), ('c', 1), ('d', 2), ('q', 1), ('t', 1)]

සටහන: අද්විතීය ගණන් නිර්මාණය කිරීම සඳහා, වෙනත් බොහෝ පිළිතුරු groupbyවිසඳුමට සාපේක්ෂව පහසු සහ වඩා කියවිය හැකි කේතයක් සපයයි . නමුත් අනුපිටපත් ගණන් කිරීමේ උදාහරණයට සමාන්තරව ඇඳීම මෙහි දක්වා ඇත.

අංකීගේ බින්කවුන්ට් භාවිතා කිරීමට යෝජනා කරන ලදි , කෙසේ වෙතත් එය ක්‍රියාත්මක වන්නේ negative ණ නොවන පූර්ණ සංඛ්‍යා සහිත 1d අරා සඳහා පමණි . එසේම, එහි ප්‍රති ar ලයක් ලෙස ඇති අරාව ව්‍යාකූල විය හැකිය (එහි මුල් ලැයිස්තුවේ මිනි සිට උපරිම දක්වා පූර්ණ සංඛ්‍යා ඇති අතර, නැතිවූ පූර්ණ සංඛ්‍යා 0 ලෙස සකසා ඇත).

අංකනය සමඟ එය කිරීමට වඩා හොඳ ක්‍රමයක් නම් සත්‍යය ලෙස සකසා ඇති ගුණාංගය සමඟ අද්විතීය ශ්‍රිතය භාවිතා කිරීමයි return_counts. එය අද්විතීය අගයන් සමූහයක් සහ එක් එක් අද්විතීය අගයේ සිදුවීම් පෙළක් සහිත ටුපල් එකක් ලබා දෙයි.

# a = [1, 1, 0, 2, 1, 0, 3, 3]
a_uniq, counts = np.unique(a, return_counts=True)  # array([0, 1, 2, 3]), array([2, 3, 1, 2]

එවිට අපට ඒවා යුගලනය කළ හැකිය

dict(zip(a_uniq, counts))  # {0: 2, 1: 3, 2: 1, 3: 2}

එය වෙනත් දත්ත වර්ග සහ "2d ලැයිස්තු" සමඟ ද ක්‍රියා කරයි, උදා

>>> a = [['a', 'b', 'b', 'b'], ['a', 'c', 'c', 'a']]
>>> dict(zip(*np.unique(a, return_counts=True)))
{'a': 3, 'b': 3, 'c': 2}

පොදු වර්ගයක් ඇති විවිධ මූලද්‍රව්‍ය ගණන ගණනය කිරීම සඳහා:

li = ['A0','c5','A8','A2','A5','c2','A3','A9']

print sum(1 for el in li if el[0]=='A' and el[1] in '01234')

ලබා දෙයි

3 , 6 නොවේ

එය ඉතා පැරණි ප්‍රශ්නයක් වුවද, මට එක ලයිනර් එකක් සොයාගත නොහැකි වූ නිසා, මම එකක් සෑදුවෙමි.

# original numbers in list
l = [1, 2, 2, 3, 3, 3, 4]

# empty dictionary to hold pair of number and its count
d = {}

# loop through all elements and store count
[ d.update( {i:d.get(i, 0)+1} ) for i in l ]

print(d)

ඔබට countOfබිල්ට් මොඩියුලයක ක්‍රමයක් ද භාවිතා කළ හැකිය operator.

>>> import operator
>>> operator.countOf([1, 2, 3, 4, 1, 4, 1], 1)
3

වඩාත්ම කාර්යක්ෂම නොවිය හැක, අනුපිටපත් ඉවත් කිරීමට අමතර අවසරයක් අවශ්‍ය වේ.

ක්‍රියාකාරී ක්‍රියාත්මක කිරීම:

arr = np.array(['a','a','b','b','b','c'])
print(set(map(lambda x  : (x , list(arr).count(x)) , arr)))

ප්‍රතිලාභ:

{('c', 1), ('b', 3), ('a', 2)}

හෝ නැවත පැමිණෙන්න dict:

print(dict(map(lambda x  : (x , list(arr).count(x)) , arr)))

ප්‍රතිලාභ:

{'b': 3, 'c': 1, 'a': 2}

sum([1 for elem in <yourlist> if elem==<your_value>])

මෙය ඔබගේ_ අගයෙහි සිදුවීම් ප්‍රමාණය නැවත ලබා දෙනු ඇත

මම භාවිතා කරමි filter(), ලූකස්ගේ උදාහරණය ගන්න:

>>> lst = [1, 2, 3, 4, 1, 4, 1]
>>> len(filter(lambda x: x==1, lst))
3

විශේෂිත මූලද්‍රව්‍යය සඳහා ඔබට සිදුවීම් ගණනාවක් අවශ්‍ය නම්:

>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> single_occurrences = Counter(z)
>>> print(single_occurrences.get("blue"))
3
>>> print(single_occurrences.values())
dict_values([3, 2, 1])

def countfrequncyinarray(arr1):
    r=len(arr1)
    return {i:arr1.count(i) for i in range(1,r+1)}
arr1=[4,4,4,4]
a=countfrequncyinarray(arr1)
print(a)

l2=[1,"feto",["feto",1,["feto"]],['feto',[1,2,3,['feto']]]]
count=0
 def Test(l):   
        global count 
        if len(l)==0:
             return count
        count=l.count("feto")
        for i in l:
             if type(i) is list:
                count+=Test(i)
        return count   
    print(Test(l2))

මෙය ලැයිස්තු ලැයිස්තුවේ වුවද ලැයිස්තුවේ ඇති අයිතමය පුනරාවර්තන ගණනය කිරීම හෝ සෙවීම සිදු කරයි