Đưa ra một mục, làm thế nào tôi có thể đếm số lần xuất hiện của nó trong một danh sách trong Python?

Nếu bạn chỉ muốn đếm một mục, hãy sử dụng countphương pháp:

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

Đừng sử dụng cái này nếu bạn muốn đếm nhiều món đồ. Gọi counttrong một vòng lặp đòi hỏi phải vượt qua danh sách riêng cho mỗi countcuộc gọi, điều này có thể là thảm họa đối với hiệu suất. Nếu bạn muốn đếm tất cả các mục, hoặc thậm chí chỉ nhiều mục, hãy sử dụng Counter, như được giải thích trong các câu trả lời khác.

Sử dụng Counternếu bạn đang sử dụng Python 2.7 hoặc 3.x và bạn muốn số lần xuất hiện cho mỗi phần tử:

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

Đếm số lần xuất hiện của một mục trong danh sách

Để đếm số lần xuất hiện của chỉ một mục danh sách bạn có thể sử dụng count()

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

Đếm số lần xuất hiện của tất cả các mục trong danh sách còn được gọi là "kiểm đếm" danh sách hoặc tạo bộ đếm kiểm đếm.

Đếm tất cả các mục với tính ()

Để đếm sự xuất hiện của các mục trong lmột người có thể chỉ cần sử dụng một cách hiểu danh sách và count()phương pháp

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

(hoặc tương tự với một từ điển dict((x,l.count(x)) for x in set(l)))

Thí dụ:

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

Đếm tất cả các mục bằng Counter ()

Ngoài ra, có Counterlớp nhanh hơn từ collectionsthư viện

Counter(l)

Thí dụ:

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

Counter nhanh hơn bao nhiêu?

Tôi đã kiểm tra xem Counterdanh sách kiểm đếm nhanh hơn bao nhiêu . Tôi đã thử cả hai phương pháp với một vài giá trị nvà có vẻ như nó Counternhanh hơn bởi hệ số không đổi xấp xỉ 2.

Đây là kịch bản tôi đã sử dụng:

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)

Và đầu ra:

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

Một cách khác để có được số lần xuất hiện của mỗi mục, trong từ điển:

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

list.count(x)trả về số lần xxuất hiện trong danh sách

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

Đưa ra một mục, làm thế nào tôi có thể đếm số lần xuất hiện của nó trong một danh sách trong Python?

Dưới đây là danh sách ví dụ:

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

list.count

Có list.countphương pháp

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

Điều này hoạt động tốt cho bất kỳ danh sách. Tuples cũng có phương pháp này:

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

collections.Counter

Và sau đó là bộ sưu tập. Gặp gỡ. Bạn có thể kết xuất bất kỳ lần lặp nào vào Bộ đếm, không chỉ là danh sách và Bộ đếm sẽ giữ lại cấu trúc dữ liệu về số lượng của các phần tử.

Sử dụng:

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

Bộ đếm dựa trên từ điển Python, các khóa của chúng là các thành phần, vì vậy các khóa cần phải được băm. Chúng cơ bản giống như các bộ cho phép các yếu tố dư thừa vào chúng.

Tiếp tục sử dụng collections.Counter

Bạn có thể thêm hoặc bớt với các lần lặp từ bộ đếm của mình:

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

Và bạn cũng có thể thực hiện nhiều thao tác với bộ đếm:

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

Tại sao không phải là gấu trúc?

Một câu trả lời khác cho thấy:

Tại sao không sử dụng gấu trúc?

Pandas là một thư viện phổ biến, nhưng nó không có trong thư viện tiêu chuẩn. Thêm nó như một yêu cầu là không tầm thường.

Có các giải pháp dựng sẵn cho trường hợp sử dụng này trong chính đối tượng danh sách cũng như trong thư viện chuẩn.

Nếu dự án của bạn chưa yêu cầu gấu trúc, sẽ thật ngu ngốc khi biến nó thành một yêu cầu chỉ dành cho chức năng này.

Tôi đã so sánh tất cả các giải pháp được đề xuất (và một vài giải pháp mới) với perfplot (một dự án nhỏ của tôi).

Đếm một mục

Đối với mảng đủ lớn, hóa ra

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

nhanh hơn một chút so với các giải pháp khác.

Đếm tất cả các mặt hàng

Như được thành lập trước đó ,

numpy.bincount(a)

là những gì bạn muốn.

Mã để tái tạo các ô:

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

Nếu bạn muốn đếm tất cả các giá trị cùng một lúc, bạn có thể thực hiện rất nhanh bằng cách sử dụng mảng numpy và bincountnhư sau

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

cái nào cho

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

Nếu bạn có thể sử dụng pandas, sau đó value_countslà để giải cứu.

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

Nó tự động sắp xếp kết quả dựa trên tần số là tốt.

Nếu bạn muốn kết quả nằm trong danh sách danh sách, hãy làm như dưới đây

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

Tại sao không sử dụng Pandas?

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

Đầu ra:

a    3
d    2
b    1
c    1
dtype: int64

Nếu bạn đang tìm kiếm số lượng của một yếu tố cụ thể, hãy nói a , thử:

my_count['a']

Đầu ra:

3

Tôi đã có vấn đề này ngày hôm nay và đưa ra giải pháp của riêng mình trước khi tôi nghĩ kiểm tra SO. Điều này:

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

là thực sự, thực sự chậm cho danh sách lớn. Giải pháp của tôi

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

thực sự nhanh hơn một chút so với giải pháp Counter, ít nhất là đối với 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)]

Dưới đây là ba giải pháp:

Nhanh nhất là sử dụng vòng lặp for và lưu trữ nó trong 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))

Kết quả

#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

Đếm tất cả các yếu tố với itertools.groupby()

Khả năng của Antoher để có được số lượng của tất cả các yếu tố trong danh sách có thể bằng phương tiện itertools.groupby().

Với số lượng "trùng lặp"

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)

Trả về

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

Lưu ý cách nó kết hợp ba anhóm đầu tiên làm nhóm đầu tiên, trong khi các nhóm khác acó mặt trong danh sách. Điều này xảy ra vì danh sách đầu vào Lkhông được sắp xếp. Điều này đôi khi có thể là một lợi ích nếu trên thực tế các nhóm nên tách biệt.

Với số lượng độc đáo

Nếu số lượng nhóm duy nhất là mong muốn, chỉ cần sắp xếp danh sách đầu vào:

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

Trả về

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

Lưu ý: Để tạo số đếm duy nhất, nhiều câu trả lời khác cung cấp mã dễ đọc và dễ đọc hơn so với groupbygiải pháp. Nhưng nó được hiển thị ở đây để vẽ song song với ví dụ đếm trùng lặp.

Nó đã được đề xuất sử dụng bincount của numpy , tuy nhiên nó chỉ hoạt động cho các mảng 1d với các số nguyên không âm . Ngoài ra, mảng kết quả có thể gây nhầm lẫn (nó chứa sự xuất hiện của các số nguyên từ min đến max của danh sách ban đầu và đặt thành 0 số nguyên bị thiếu).

Một cách tốt hơn để làm điều đó với numpy là sử dụng hàm duy nhất với thuộc tính return_countsđược đặt thành True. Nó trả về một tuple với một mảng các giá trị duy nhất và một mảng các lần xuất hiện của mỗi giá trị duy nhất.

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

và sau đó chúng ta có thể ghép chúng thành

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

Nó cũng hoạt động với các loại dữ liệu khác và "danh sách 2d", vd

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

Để đếm số lượng phần tử đa dạng có loại phổ biến:

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

cho

3 , không phải 6

Mặc dù đây là một câu hỏi rất cũ, nhưng vì tôi không tìm thấy một lớp lót nào, tôi đã làm một cái.

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

Bạn cũng có thể sử dụng countOfphương pháp của một mô-đun tích hợp operator.

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

Có thể không phải là hiệu quả nhất, đòi hỏi một vượt qua để loại bỏ trùng lặp.

Thực hiện chức năng:

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

trả về:

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

hoặc trả lại dưới dạng dict:

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

trả về:

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

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

Điều này sẽ trả về số lần xuất hiện của your_value

Tôi sẽ sử dụng filter(), lấy ví dụ của Lukasz:

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

nếu bạn muốn một số lần xuất hiện cho phần tử cụ thể:

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

điều này sẽ đếm đệ quy hoặc tìm kiếm mục trong danh sách ngay cả khi nó trong danh sách