Python Language
Compte

Compter toutes les occurrences de tous les éléments dans un iterable: 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

Les collections.Counter peuvent être utilisées pour toute itération et compte chaque occurrence pour chaque élément.

Note : Une exception est si un dict ou une autre collections.Mapping classe-like est donnée, alors elle ne les comptera pas, mais crée un compteur avec ces valeurs:

Counter({"e": 2})
# Out: Counter({"e": 2})

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

Obtenir la valeur la plus courante (-s): collections.Counter.most_common ()

Compter les clés d'un Mapping n'est pas possible avec collections.Counter mais nous pouvons compter les valeurs :

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

Les éléments les plus courants sont disponibles par la most_common 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)]

Compter les occurrences d'un élément dans une séquence: list.count () et 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

Compter les occurrences d'une sous-chaîne dans une chaîne: str.count ()

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

Cela fonctionne même pour des sous-chaînes de plus d'un caractère:

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

ce qui ne serait pas possible avec des collections.Counter qui ne compte que des caractères simples:

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

Comptage des occurrences dans le tableau numpy

Pour compter les occurrences d'une valeur dans un tableau numpy. Cela fonctionnera:

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

La logique est que l'instruction booléenne produit un tableau où toutes les occurrences des valeurs demandées sont 1 et toutes les autres sont zéro. Donc, en les additionnant, vous obtenez le nombre d'occurrences. Cela fonctionne pour les tableaux de toute forme ou dtype.

Il existe deux méthodes pour compter les occurrences de toutes les valeurs uniques dans numpy. Unique et montant. Unique aplatit automatiquement les tableaux multidimensionnels, tandis que bincount ne fonctionne qu'avec les tableaux 1d contenant uniquement des entiers positifs.

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

Si vos données sont des tableaux numpy, il est généralement beaucoup plus rapide d'utiliser les méthodes numpy que de convertir vos données en méthodes génériques.