Python Language
Räkning

Räknar all förekomst av alla objekt i en iterable: samlingar

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 kan användas för alla iterable och räknar varje händelse för varje element.

Obs : Ett undantag är om en dict eller en annan collections.Mapping Kartläggningsliknande klass ges, då räknar de inte, snarare skapar det en räknare med dessa värden:

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

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

Få det vanligaste värdet (-s): samlingar.Counter.most_common ()

Det är inte möjligt att räkna nycklarna till en Mapping med collections.Counter men vi kan räkna värdena :

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

De vanligaste elementen är tillgängliga av den most_common metoden:

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

Räkna förekomsten av ett objekt i en sekvens: list.count () och 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

Räkna förekomsten av en substring i en sträng: str.count ()

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

Detta fungerar även för underlag längre än ett tecken:

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

vilket inte skulle vara möjligt med collections.Counter som bara räknar enstaka tecken:

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

Räkna händelser i numpy matris

Att räkna förekomsten av ett värde i en numpy matris. Detta fungerar:

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

Logiken är att det booleska uttalandet producerar en matris där alla förekomster av de begärda värdena är 1 och alla andra är noll. Så att summera dessa ger antalet händelser. Detta fungerar för matriser av vilken form som helst eller vilken typ som helst.

Det finns två metoder jag använder för att räkna förekomster av alla unika värden i numpy. Unikt och bincount. Unika plattar automatiskt flerdimensionella matriser, medan bincount endast fungerar med 1d-arrayer som endast innehåller positiva heltal.

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

Om dina data är numpy-matriser är det i allmänhet mycket snabbare att använda numpy-metoder för att konvertera dina data till generiska metoder.