Bagaimana saya bisa menghitung kemunculan item daftar?


1530

Diberikan item, bagaimana saya bisa menghitung kemunculannya dalam daftar dengan Python?

Jawaban:


1853

Jika Anda hanya menginginkan hitungan satu item, gunakan countmetode ini:

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

Jangan gunakan ini jika Anda ingin menghitung banyak item. Memanggil countdalam satu lingkaran memerlukan pass terpisah dari daftar untuk setiap countpanggilan, yang dapat menjadi bencana bagi kinerja. Jika Anda ingin menghitung semua item, atau bahkan hanya beberapa item, gunakan Counter, seperti yang dijelaskan dalam jawaban lainnya.


6
mylist = [1,7,7,7,3,9,9,9,7,9,10,0] print sorted(set([i for i in mylist if mylist.count(i)>2]))
cpp-coder

1746

Gunakan Counterjika Anda menggunakan Python 2.7 atau 3.x dan Anda ingin jumlah kemunculan untuk setiap elemen:

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

2
Saya telah menemukan bahwa ketika menggunakan ini banyak (berbicara tentang jutaan string) itu sangat lambat karena panggilannya isinstance. Jadi jika Anda yakin tentang data yang sedang Anda kerjakan, mungkin lebih baik untuk menulis fungsi kustom tanpa jenis dan contoh memeriksa.
Bram Vanroy

2
@BramVanroy: isinstancePanggilan apa ? Bahkan dengan jutaan string, panggilan Counterhanya melibatkan satu isinstancepanggilan, untuk memeriksa apakah argumennya adalah pemetaan. Anda kemungkinan besar salah menilai apa yang memakan waktu Anda.
user2357112 mendukung Monica

Anda salah mengartikan apa yang saya maksud: Counter memeriksa tipe data Anda sebelum membuat Counter. Ini membutuhkan waktu relatif banyak dan jika Anda mengetahui jenis data Anda sebelumnya. Jika Anda melihat metode pembaruan Counter, Anda akan melihatnya harus melalui tiga pernyataan if sebelum melakukan sesuatu. Jika Anda sering menelepon pembaruan, ini bertambah dengan cepat. Ketika Anda memiliki kontrol atas data Anda dan Anda tahu bahwa inputnya memang akan dapat diulang, maka Anda dapat melewati dua pemeriksaan pertama. Seperti yang saya katakan, saya hanya memperhatikan ini ketika bekerja dengan jutaan pembaruan sehingga ini merupakan kasus tepi.
Bram Vanroy

2
@BramVanroy: Jika Anda melakukan jutaan pembaruan daripada hanya menghitung jutaan string, itu cerita yang berbeda. Upaya pengoptimalan Countertelah dimasukkan ke menghitung iterables besar, daripada menghitung iterables banyak. Menghitung sejuta-string iterable akan berjalan lebih cepat dengan Counterdaripada dengan implementasi manual. Jika Anda ingin menelepon updatedengan banyak iterables, Anda mungkin dapat mempercepat dengan menggabungkannya menjadi satu iterable dengan itertools.chain.
user2357112 mendukung Monica

262

Menghitung kemunculan satu item dalam daftar

Untuk menghitung kemunculan hanya satu item daftar yang dapat Anda gunakan count()

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

Menghitung kemunculan semua item dalam daftar juga dikenal sebagai "penghitungan" daftar, atau membuat penghitungan penghitungan.

Menghitung semua item dengan count ()

Untuk menghitung kemunculan item dalam lsatu cukup menggunakan daftar pemahaman dan count()metode

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

(atau mirip dengan kamus dict((x,l.count(x)) for x in set(l)))

Contoh:

>>> 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}

Menghitung semua item dengan Penghitung ()

Atau, ada Counterkelas yang lebih cepat dari collectionsperpustakaan

Counter(l)

Contoh:

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

Seberapa cepat Counter?

Saya memeriksa seberapa cepat Counterdaftar penghitungan. Saya mencoba kedua metode dengan beberapa nilai ndan tampaknya Counterlebih cepat dengan faktor konstan sekitar 2.

Berikut ini skrip yang saya gunakan:

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)

Dan hasilnya:

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

32
Counteradalah cara yang lebih cepat untuk daftar yang lebih besar. Metode pemahaman daftar adalah O (n ^ 2), Counterharus O (n).
fhucho

20
Penghitung tidak lebih cepat dengan faktor 2, Penghitung lebih cepat dengan faktor n (O (n ^ 2) vs O (n)).
Martijn Pieters

Saya telah menemukan bahwa ketika menggunakan ini banyak (berbicara tentang jutaan string) itu sangat lambat karena panggilannya isinstance. Jadi jika Anda yakin tentang data yang sedang Anda kerjakan, mungkin lebih baik untuk menulis fungsi kustom tanpa jenis dan contoh memeriksa.
Bram Vanroy

66

Cara lain untuk mendapatkan jumlah kemunculan setiap item, dalam kamus:

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

49
ini terlihat seperti salah satu konstruksi yang sering saya munculkan dalam panasnya pertempuran, tetapi akan berjalan melalui len (a) kali yang berarti kompleksitas runtime kuadratik (karena setiap run tergantung pada len (a) lagi).
Nicolas78

5
akankah dict ((i, a.count (i)) untuk saya di set (a)) lebih benar dan lebih cepat?
hugo24

6
@ hugo24: Sedikit, tetapi tidak akan lebih cepat tanpa gejala dalam kasus terburuk; itu akan membutuhkan n * (number of different items)operasi, tidak menghitung waktu yang diperlukan untuk membangun set. Penggunaannya collections.Counterjauh lebih baik.
Clément

sangat terlambat ke pesta tetapi tidak akan mengikuti kode melemparkan kesalahan jika daftar berisi lebih dari satu contoh i, karena akan mencoba memasukkan beberapa kunci dengan nilai yang sama dalam kamus. dict((i, a.count(i)) for i in a)
rp1


45

Diberikan item, bagaimana saya bisa menghitung kemunculannya dalam daftar dengan Python?

Berikut daftar contohnya:

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

list.count

Itu list.countmetodenya

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

Ini berfungsi dengan baik untuk daftar apa pun. Tuples juga memiliki metode ini:

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

collections.Counter

Dan kemudian ada koleksi. Penghitung. Anda bisa membuang semua iterable ke Counter, bukan hanya daftar, dan Counter akan mempertahankan struktur data dari jumlah elemen.

Pemakaian:

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

Penghitung didasarkan pada kamus Python, kuncinya adalah elemen, sehingga kuncinya harus dapat di hashable. Mereka pada dasarnya seperti set yang memungkinkan elemen berlebihan ke dalamnya.

Penggunaan lebih lanjut dari collections.Counter

Anda dapat menambah atau mengurangi dengan iterables dari counter Anda:

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

Dan Anda dapat melakukan operasi multi-set dengan penghitung juga:

>>> 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})

Kenapa tidak panda?

Jawaban lain menunjukkan:

Mengapa tidak menggunakan panda?

Panda adalah perpustakaan umum, tetapi tidak ada di perpustakaan standar. Menambahkannya sebagai persyaratan adalah tidak sepele.

Ada solusi bawaan untuk kasus penggunaan ini di objek daftar itu sendiri maupun di perpustakaan standar.

Jika proyek Anda belum membutuhkan panda, bodoh jika menjadikannya persyaratan hanya untuk fungsi ini.


4
Sementara "mengapa tidak Pandas" sesuai, itu mungkin harus disertai dengan "kapan harus menggunakan NumPy", yaitu untuk array numerik besar. Faktor penentu bukan hanya keterbatasan proyek, ada efisiensi memori dengan NumPy yang menjadi jelas dengan data besar.
jpp

Terima kasih telah menyebut Pandas / etc sebagai ketergantungan serius. Beberapa paket ini memiliki efek samping negatif. Jadi penambahan aset ini untuk kebutuhan sepele bisa menghabiskan banyak waktu dan $. Secara pribadi saya telah mengalami Numpy dan SciPi menambahkan 30 menit ke pipa CI kami dan butuh berhari-hari untuk mendapatkan cache paket dengan benar. Paket bagus, tapi terkadang ada biaya tersembunyi. Memberi +1
Marc

36

Saya telah membandingkan semua solusi yang disarankan (dan beberapa yang baru) dengan perfplot (proyek kecil saya).

Menghitung satu item

Untuk array yang cukup besar, ternyata itu

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

sedikit lebih cepat daripada solusi lainnya.

masukkan deskripsi gambar di sini

Menghitung semua item

Seperti yang ditetapkan sebelumnya ,

numpy.bincount(a)

adalah apa yang kamu inginkan.

masukkan deskripsi gambar di sini


Kode untuk mereproduksi plot:

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,
    )

7
numpy.bincount () hanya akan berfungsi untuk daftar dengan item int.
Mukarram Pasha

35

Jika Anda ingin menghitung semua nilai sekaligus, Anda dapat melakukannya dengan sangat cepat menggunakan numpy array dan bincountsebagai berikut

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

pemberian yang mana

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

19

Jika Anda dapat menggunakan pandas, maka value_countsada untuk penyelamatan.

>>> 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

Secara otomatis mengurutkan hasil berdasarkan frekuensi juga.

Jika Anda ingin hasilnya ada dalam daftar, lakukan seperti di bawah ini

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

panda memiliki banyak overhead, jadi itu solusi paling lambat dengan sejumlah kecil data. stackoverflow.com/a/46195192/125507
endolith

14

Mengapa tidak menggunakan Panda?

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

Keluaran:

a    3
d    2
b    1
c    1
dtype: int64

Jika Anda mencari hitungan elemen tertentu, katakan a , coba:

my_count['a']

Keluaran:

3

13

Saya memiliki masalah ini hari ini dan memutar solusi saya sendiri sebelum saya berpikir untuk memeriksa SO. Ini:

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

benar-benar lambat untuk daftar besar. Solusi saya

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

sebenarnya sedikit lebih cepat daripada solusi Counter, setidaknya untuk Python 2.7.


1
Konter mengurutkan entri sementara milik Anda tidak, karenanya perbedaan kecepatan (Benar pada saat penulisan, tidak yakin apakah itu ketika Anda menulis jawabannya. Namun, itu mungkin relevan untuk seseorang yang menggulir ke bawah.)
chaosflaw

3
Penghitung di Python 2 sedikit lambat, ya. Namun menggunakan kode C-dioptimalkan untuk melakukan penghitungan di Python 3, dan sekarang mengalahkan loop Anda dengan mudah.
Martijn Pieters

12
# 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)]

2
@plaes: Bagaimana bisa begitu? Jika dengan 'enterprisey', maksud Anda "didokumentasikan" dalam persiapan untuk penjelasan Py3k, saya setuju.
Wes Turner

1
Ini adalah contoh yang bagus, karena saya mengembangkan terutama di 2.7, tetapi harus memiliki jalur migrasi ke 2.4.
Adam Lewis

9

Di bawah ini adalah tiga solusi:

Tercepat menggunakan for for dan menyimpannya dalam 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))

Hasil

#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

9

Hitung semua elemen dengan itertools.groupby()

Kemungkinan lebih lanjut untuk mendapatkan jumlah semua elemen dalam daftar bisa melalui itertools.groupby().

Dengan jumlah "duplikat"

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)

Kembali

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

Perhatikan bagaimana ini menggabungkan tiga yang pertama asebagai kelompok pertama, sementara kelompok lain ahadir lebih jauh dalam daftar. Ini terjadi karena daftar input Ltidak diurutkan. Ini bisa bermanfaat kadang-kadang jika kelompok sebenarnya terpisah.

Dengan jumlah unik

Jika jumlah kelompok unik diinginkan, cukup sortir daftar input:

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

Kembali

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

Catatan: Untuk membuat hitungan unik, banyak jawaban lain memberikan kode yang lebih mudah dan lebih mudah dibaca dibandingkan dengan groupbysolusinya. Tetapi ditunjukkan di sini untuk menggambar paralel dengan contoh jumlah duplikat.


7

Disarankan untuk menggunakan bincount numpy , namun hanya berfungsi untuk array 1d dengan bilangan bulat non-negatif . Juga, array yang dihasilkan mungkin membingungkan (berisi kemunculan bilangan bulat dari min ke maks dari daftar asli, dan set ke 0 bilangan yang hilang).

Cara yang lebih baik untuk melakukannya dengan numpy adalah menggunakan fungsi unik dengan atribut return_countsdisetel ke True. Ini mengembalikan tuple dengan array nilai unik dan array kemunculan setiap nilai unik.

# 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]

dan kemudian kita bisa memasangkannya sebagai

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

Ini juga bekerja dengan tipe data lain dan "daftar 2d", misalnya

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

6

Untuk menghitung jumlah elemen beragam yang memiliki tipe umum:

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')

memberi

3 , bukan 6



3

Anda juga dapat menggunakan countOfmetode modul bawaan operator.

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

1
Bagaimana countOfpenerapannya? Bagaimana cara membandingkannya dengan yang lebih jelas list.count(yang diuntungkan dari implementasi C)? Apakah ada kelebihannya?
Chris_Rands

2

Mungkin bukan yang paling efisien, memerlukan izin ekstra untuk menghapus duplikat.

Implementasi fungsional:

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

pengembalian:

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

atau kembali sebagai dict:

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

pengembalian:

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

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

Ini akan mengembalikan jumlah kemunculan nilai_Anda


1

Saya akan menggunakan filter(), ambil contoh Lukasz:

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

0

jika Anda menginginkan sejumlah kemunculan untuk elemen tertentu:

>>> 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])

-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)

3
Sementara kode ini dapat menjawab pertanyaan, memberikan konteks tambahan tentang mengapa dan / atau bagaimana kode ini menjawab pertanyaan meningkatkan nilai jangka panjangnya.
Alex Riabov

-1
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))

ini akan menghitung berulang atau mencari item dalam daftar bahkan jika itu dalam daftar daftar


saya tidak tahu mengapa ada orang yang memilih jawaban dan itu sangat berguna
Mohamed Fathallah
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.