Python Language
Zählen
Suche…
Zählen aller Vorkommen aller Elemente in einer iterierbaren: 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
Der collections.Counter kann für jedes beliebige Element verwendet werden und zählt jedes Vorkommen für jedes Element.
Hinweis : Eine Ausnahme ist, wenn ein dict oder eine andere collections.Mapping Klasse angegeben ist. Dann werden sie nicht gezählt, sondern es wird ein Counter mit den folgenden Werten erstellt:
Counter({"e": 2})
# Out: Counter({"e": 2})
Counter({"e": "e"}) # warning Counter does not verify the values are int
# Out: Counter({"e": "e"})
Den häufigsten Wert (-s) ermitteln: Collections.Counter.most_common ()
Das Zählen der Schlüssel eines Mapping ist bei collections.Counter nicht möglich. Zähler, aber wir können die Werte zählen :
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})
Die häufigsten Elemente sind mit der most_common Methode 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)]
Zählen der Vorkommen eines Elements in einer Sequenz: list.count () und 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
Zählen der Vorkommen eines Teilstrings in einem String: str.count ()
astring = 'thisisashorttext'
astring.count('t')
# Out: 4
Dies funktioniert auch für Teilzeichenfolgen, die länger als ein Zeichen sind:
astring.count('th')
# Out: 1
astring.count('is')
# Out: 2
astring.count('text')
# Out: 1
was mit collections.Counter nicht möglich wäre. Zähler, der nur einzelne Zeichen zählt:
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})
Zählung von Vorkommen im numpy-Array
Zählen der Vorkommen eines Werts in einem numpy-Array. Das wird funktionieren:
>>> import numpy as np
>>> a=np.array([0,3,4,3,5,4,7])
>>> print np.sum(a==3)
2
Die Logik ist, dass die boolesche Anweisung ein Array erzeugt, in dem alle Vorkommen der angeforderten Werte 1 sind und alle anderen Null sind. Das Summieren dieser Werte ergibt also die Anzahl der Vorkommen. Dies funktioniert für Arrays mit beliebigen Formen oder Datentypen.
Ich verwende zwei Methoden, um Vorkommen aller eindeutigen Werte in numpy zu zählen. Einzigartig und zahlreich. Unique reduziert automatisch mehrdimensionale Arrays, während bincount nur bei 1d-Arrays funktioniert, die nur positive Ganzzahlen enthalten.
>>> 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]
Wenn Ihre Daten aus numpy-Arrays bestehen, ist es im Allgemeinen viel schneller, numpy-Methoden zu verwenden, als Ihre Daten in generische Methoden umzuwandeln.