Подсчет количества элементов в коллекции

Введение

Примеры

  • 1

    Подсчет всех вхождений всех элементов в итерируемом: collection.Counter

     from collections import Counter
    
    c = Counter(["a", "b", "c", "d", "a", "b", "a", "c", "d"])
    c
    # Out: Counter({'a': 3, 'b': 2, 'c': 2, 'd': 2})
    c["a"]
    # Out: 3
    
    c[7]     # not in the list (7 occurred 0 times!)
    # Out: 0
    
     

    collections.Counter может быть использован для любого итератора и подсчитывает каждое вхождение для каждого элемента.

    Примечание: Одно исключение , если dict или другой collections.Mapping -как класса дается, то он не будет считать их, а это создает счетчик с этими значениями:

     Counter({"e": 2})
    # Out: Counter({"e": 2})
    
    Counter({"e": "e"})        # warning Counter does not verify the values are int
    # Out: Counter({"e": "e"}) 
  • 1

    Получение наиболее распространенного значения (-s): collection.Counter.most_common ()

    Подсчет ключи от Mapping не представляется возможным с collections.Counter , но мы можем рассчитывать значения:

     from collections import Counter
    adict = {'a': 5, 'b': 3, 'c': 5, 'd': 2, 'e':2, 'q': 5}
    Counter(adict.values())
    # Out: Counter({2: 2, 3: 1, 5: 3})
    
     

    Наиболее распространенные элементы в докладе доступны most_common -метода:

     # Sorting them from most-common to least-common value:
    Counter(adict.values()).most_common()
    # Out: [(5, 3), (2, 2), (3, 1)]
    
    # Getting the most common value
    Counter(adict.values()).most_common(1)
    # Out: [(5, 3)]
    
    # Getting the two most common values
    Counter(adict.values()).most_common(2)
    # Out: [(5, 3), (2, 2)] 
  • 1

    Подсчет вхождений одного элемента в последовательности: list.count () и tuple.count ()

     alist = [1, 2, 3, 4, 1, 2, 1, 3, 4]
    alist.count(1)
    # Out: 3
    
    atuple = ('bear', 'weasel', 'bear', 'frog')
    atuple.count('bear')
    # Out: 2
    atuple.count('fox')
    # Out: 0 
  • 0

    Подсчет вхождений подстроки в строку: str.count ()

     astring = 'thisisashorttext'
    astring.count('t')
    # Out: 4
    
     

    Это работает даже для подстрок длиннее одного символа:

     astring.count('th')
    # Out: 1
    astring.count('is')
    # Out: 2
    astring.count('text')
    # Out: 1
    
     

    которое не было бы возможно с collections.Counter , который только подсчитывает одиночные символы:

     from collections import Counter
    Counter(astring)
    # Out: Counter({'a': 1, 'e': 1, 'h': 2, 'i': 2, 'o': 1, 'r': 1, 's': 3, 't': 4, 'x': 1}) 
  • 0

    Подсчет вхождений в массиве NumPy

    Для подсчета вхождений значения в массиве numpy. Это будет работать:

     >>> import numpy as np
    >>> a=np.array([0,3,4,3,5,4,7])
    >>> print np.sum(a==3)
    2
    
     

    Логика заключается в том, что логическое выражение создает массив, в котором все вхождения запрошенных значений равны 1, а все остальные равны нулю. Таким образом, суммируя их, мы получим количество случаев. Это работает для массивов любой формы или типа.

    Есть два метода, которые я использую для подсчета вхождения всех уникальных значений в numpy. Уникальный и bincount. Unique автоматически выравнивает многомерные массивы, тогда как bincount работает только с 1d массивами, содержащими только положительные целые числа.

     >>> unique,counts=np.unique(a,return_counts=True)
    >>> print unique,counts # counts[i] is equal to occurrences of unique[i] in a
    [0 3 4 5 7] [1 2 2 1 1]
    >>> bin_count=np.bincount(a)
    >>> print bin_count # bin_count[i] is equal to occurrences of i in a
    [1 0 0 2 2 1 0 1] 
    
    
    
     

    Если ваши данные представляют собой массивы numpy, как правило, гораздо быстрее использовать методы numpy, чем преобразовывать данные в универсальные методы.

Синтаксис

Параметры

Примечания