항목이 주어지면 파이썬의 목록에서 항목을 어떻게 계산할 수 있습니까?

하나의 항목 수만 원하면 다음 count방법을 사용하십시오 .

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

여러 항목을 세려면이 옵션을 사용 하지 마십시오 . count루프에서 호출 하려면 모든 count호출에 대해 목록에 대해 별도의 패스가 필요하며 이는 성능면에서 치명적일 수 있습니다. 모든 항목을 계산하거나 여러 항목을 계산 Counter하려면 다른 답변에서 설명한대로를 사용 하십시오.

CounterPython 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

목록에서 모든 항목 의 발생 횟수를 계산하는 것은 목록을 "계산"하거나 집계 카운터를 만드는 것으로도 알려져 있습니다.

count ()를 사용하여 모든 항목 계산

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 ()로 모든 항목 계산

또는 도서관 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

그리고 컬렉션이 있습니다. 목록뿐만 아니라 카운터에 iterable을 덤프 할 수 있으며 카운터는 요소 수의 데이터 구조를 유지합니다.

용법:

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

카운터는 Python 사전을 기반으로하며 키는 요소이므로 키를 해시 할 수 있어야합니다. 그것들은 기본적으로 중복 요소를 허용하는 세트와 같습니다.

추가 사용 collections.Counter

카운터에서 iterables를 더하거나 뺄 수 있습니다.

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

빈도에 따라 결과를 자동으로 정렬합니다.

결과를 목록 목록에 표시하려면 다음과 같이하십시오.

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

실제로 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)]

다음은 세 가지 솔루션입니다.

가장 빠른 것은 for 루프를 사용하여 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))

결과

#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솔루션에 비해 쉽고 읽기 쉬운 코드를 제공합니다. 그러나 중복 카운트 예제와 평행을 이루는 것이 여기에 표시됩니다.

numpy의 bincount 사용을 제안 했지만 음수가 아닌 정수가있는 1d 배열에서만 작동합니다 . 또한 결과 배열은 혼란 스러울 수 있습니다 (원래 목록의 최소에서 최대까지의 정수 발생을 포함하고 누락 된 정수를 0으로 설정).

numpy로 수행하는 더 좋은 방법 은 속성 을 True로 설정 하여 고유 한 함수 를 사용하는 것 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>])

이것은 your_value의 발생량을 반환합니다

나는 filter()Lukasz의 예제를 사용한다.

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

목록의 목록에 있더라도 목록의 항목을 재귀 적으로 계산하거나 검색합니다.