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

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.

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

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]

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

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

list.count(x)mengembalikan berapa kali xmuncul dalam daftar

lihat: http://docs.python.org/tutorial/datastructures.html#more-on-lists

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.

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.

Menghitung semua item

Seperti yang ditetapkan sebelumnya ,

numpy.bincount(a)

adalah apa yang kamu inginkan.

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

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

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

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

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.

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

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

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.

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}

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

Meskipun ini adalah pertanyaan yang sangat lama, tetapi karena saya tidak menemukan satu liner, saya membuatnya.

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

Anda juga dapat menggunakan countOfmetode modul bawaan operator.

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

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}

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

Ini akan mengembalikan jumlah kemunculan nilai_Anda

Saya akan menggunakan filter(), ambil contoh Lukasz:

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

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

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

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