Python Language
tellen
Zoeken…
Het tellen van alle exemplaren van alle items in een iterabele: collections.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
De collections.Counter kan worden gebruikt voor elke iterabele en telt elke gebeurtenis voor elk element.
Opmerking : Een uitzondering is als een dict of een andere collections.Mapping wordt toegewezen. Als een klasse wordt toegewezen, telt deze niet mee, maar wordt een teller met deze waarden gemaakt:
Counter({"e": 2})
# Out: Counter({"e": 2})
Counter({"e": "e"}) # warning Counter does not verify the values are int
# Out: Counter({"e": "e"})
De meest voorkomende waarde (-s) verkrijgen: collections.Counter.most_common ()
Het tellen van de sleutels van een Mapping is niet mogelijk met collections.Counter Teller maar we kunnen de waarden tellen:
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 meest voorkomende elementen zijn beschikbaar door de most_common -methode:
# 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)]
Het voorkomen van één item in een reeks: list.count () en 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
Het voorkomen van een substring in een string: str.count ()
astring = 'thisisashorttext'
astring.count('t')
# Out: 4
Dit werkt zelfs voor substrings die langer zijn dan één teken:
astring.count('th')
# Out: 1
astring.count('is')
# Out: 2
astring.count('text')
# Out: 1
wat niet mogelijk zou zijn met collections.Counter die alleen enkele tekens telt:
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})
Tellingen van een aantal in een reeks
Om het voorkomen van een waarde in een numpy array te tellen. Dit werkt:
>>> import numpy as np
>>> a=np.array([0,3,4,3,5,4,7])
>>> print np.sum(a==3)
2
De logica is dat de booleaanse instructie een array produceert waarbij alle exemplaren van de gevraagde waarden 1 zijn en alle andere nul zijn. Dus het optellen van deze geeft het aantal voorvallen. Dit werkt voor arrays van elke vorm of dtype.
Er zijn twee methoden die ik gebruik om exemplaren van alle unieke waarden in aantal te tellen. Uniek en bincount. Uniek maakt multidimensionale arrays automatisch vlak, terwijl bincount alleen werkt met 1d-arrays die alleen positieve gehele getallen bevatten.
>>> 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]
Als uw gegevens numpy arrays zijn, is het over het algemeen veel sneller om numpy methoden te gebruiken dan om uw gegevens naar generieke methoden om te zetten.