Python-Zähler: Wie verwende ichcollections.Counter?

1. Einführung

Ein Counter-Tool ermöglicht schnelles und bequemes Zählen. Counter ist eine Unterklasse von dict, die zum Zählen hashbarer Objekte verwendet wird. Es handelt sich um eine Sammlung mit Elementen, die wie Wörterbuchschlüssel gespeichert sind, und deren Anzahl als Werte. Counts können beliebige ganzzahlige Werte sein, einschließlich 0 und negativer Zahlen, und die Counter-Klasse ähnelt in etwa den Bags oder Multisets in anderen Sprachen. Um es einfach auszudrücken: Schauen wir uns zur Verdeutlichung ein paar Beispiele an.
Beispiel:

#计算top10的单词
from collections import Counter
import re
text = 'remove an existing key one level down remove an existing key one level down'
words = re.findall(r'\w+', text)
Counter(words).most_common(10)
[('remove', 2),('an', 2),('existing', 2),('key', 2),('one', 2)('level', 2),('down', 2)] 


#计算列表中单词的个数
cnt = Counter()
for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
    cnt[word] += 1
cnt
Counter({'red': 2, 'blue': 3, 'green': 1})


#上述这样计算有点嘛，下面的方法更简单，直接计算就行
L = ['red', 'blue', 'red', 'green', 'blue', 'blue'] 
Counter(L)
Counter({'red': 2, 'blue': 3, 'green': 1}

Elemente werden aus einer iterierbaren oder initialisierten Zuordnung (oder einem anderen Zähler) gezählt:

from collections import Counter

#字符串计数
Counter('gallahad') 
Counter({'g': 1, 'a': 3, 'l': 2, 'h': 1, 'd': 1})

#字典计数
Counter({'red': 4, 'blue': 2})  
Counter({'red': 4, 'blue': 2})

#计数
Counter(cats=4, dogs=8)
Counter({'cats': 4, 'dogs': 8})

Counter(['red', 'blue', 'red', 'green', 'blue', 'blue'])
Counter({'red': 2, 'blue': 3, 'green': 1})

2. Zählen Sie die Anzahl der Vorkommen jedes Elements in der „iterierbaren Sequenz“

1.1 Auswirkung auf Liste/String

Es gibt zwei Möglichkeiten, es zu verwenden: Eine besteht darin, es direkt zu verwenden, und die andere darin, es nach der Instanziierung zu verwenden. Wenn Sie es häufig aufrufen möchten, ist die letztere natürlich prägnanter Sie können Counter einfach aufrufen. Die verschiedenen Methoden sind für andere iterierbare Sequenzen gleich.

#首先引入该方法
from collections import Counter
#对列表作用
list_01 = [1,9,9,5,0,8,0,9]  #GNZ48-陈珂生日
print(Counter(list_01))  #Counter({9: 3, 0: 2, 1: 1, 5: 1, 8: 1})
 
#对字符串作用
temp = Counter('abcdeabcdabcaba')
print(temp)  #Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
#以上其实是两种使用方法，一种是直接用，一种是实例化以后使用,如果要频繁调用的话，显然后一种更简洁

1.2 Ergebnisse ausgeben

#查看类型
print( type(temp) ) #<class &#39;collections.Counter&#39;>
 
#转换为字典后输出
print( dict(temp) ) #{&#39;b&#39;: 4, &#39;a&#39;: 5, &#39;c&#39;: 3, &#39;d&#39;: 2, &#39;e&#39;: 1}
 
for num,count in enumerate(dict(temp).items()):
    print(count)
"""
(&#39;e&#39;, 1)
(&#39;c&#39;, 3)
(&#39;a&#39;, 5)
(&#39;b&#39;, 4)
(&#39;d&#39;, 2)
"""

1.3 Verwenden Sie die integrierte Methode items() zur Ausgabe

Diese Methode ist natürlich bequemer als die Konvertierung in ein Wörterbuch und die anschließende Ausgabe:

print(temp.items()) #dict_items([('e', 1), ('c', 3), ('b', 4), ('d', 2), ('a', 5)])
 
for item in temp.items():
    print(item)
"""
('a', 5)
('c', 3)
('d', 2)
('e', 1)
('b', 4)
"""

2 häufig vorkommendes Element

verwendet die Methode most_common(), um eine Liste mit den n häufigsten Elementen und deren Häufigkeit zurückzugeben, sortiert nach Häufigkeit von hoch nach niedrig. Wenn n weggelassen wird oder keine, gibt most_common() alle Elemente im Zähler zurück. Elemente mit gleichen Zählwerten werden in der Reihenfolge ihres ersten Auftretens sortiert:

#求序列中出现次数最多的元素
 
from collections import Counter
 
list_01 = [1,9,9,5,0,8,0,9]
temp = Counter(list_01)
 
#统计出现次数最多的一个元素
print(temp.most_common(1))   #[(9, 3)]  元素“9”出现3次。
print(temp.most_common(2)) #[(9, 3), (0, 2)]  统计出现次数最多个两个元素
 
#没有指定个数，就列出全部
print(temp.most_common())  #[(9, 3), (0, 2), (1, 1), (5, 1), (8, 1)]

rrree

3. ) und sort ()Methode

Beschreibung: Gibt einen Iterator zurück, in dem jedes Element so oft wiederholt wird, wie durch den Zählwert angegeben. Elemente werden in der Reihenfolge ihres ersten Auftretens zurückgegeben. Wenn die Anzahl eines Elements kleiner als 1 ist, ignoriert elements() es.

Beispiel:

Counter('abracadabra').most_common(3)
[('a', 5), ('b', 2), ('r', 2)]

Counter('abracadabra').most_common(5)
[('a', 5), ('b', 2), ('r', 2), ('c', 1), ('d', 1)]

c = Counter(a=4, b=2, c=0, d=-2)
list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

sorted(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

c = Counter(a=4, b=2, c=0, d=5)
list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b', 'd', 'd', 'd', 'd', 'd']

Offizielles Dokumentbeispiel:

from collections import Counter
 
c = Counter('ABCABCCC')
print(c.elements()) #<itertools.chain object at 0x0000027D94126860>
 
#尝试转换为list
print(list(c.elements())) #[&#39;A&#39;, &#39;A&#39;, &#39;C&#39;, &#39;C&#39;, &#39;C&#39;, &#39;C&#39;, &#39;B&#39;, &#39;B&#39;]
 
#或者这种方式
print(sorted(c.elements()))  #[&#39;A&#39;, &#39;A&#39;, &#39;B&#39;, &#39;B&#39;, &#39;C&#39;, &#39;C&#39;, &#39;C&#39;, &#39;C&#39;]
 
#这里与sorted的作用是： list all unique elements，列出所有唯一元素
#例如
print( sorted(c) ) #[&#39;A&#39;, &#39;B&#39;, &#39;C&#39;]

4. Die Ausgabe ignoriert nicht die Anzahl, deren Ergebnis Null oder kleiner als Null ist. Subtrahieren Sie Elemente vom iterativen Objekt oder Kartenobjekt, beide Eingaben und Ausgabe Kann 0 oder negativ sein.

# Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1
prime_factors = Counter({2: 2, 3: 3, 17: 1})
product = 1
for factor in prime_factors.elements():  # loop over factors
    product *= factor  # and multiply them
print(product)  #1836
#1836 = 2*2*3*3*3*17

c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4)
c.subtract(d)
c
Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

#减去一个abcd
str0 = Counter('aabbccdde')
str0
Counter({'a': 2, 'b': 2, 'c': 2, 'd': 2, 'e': 1})

str0.subtract('abcd')
str0
Counter({'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1}

Die Anzahl kann hier auf Null reduziert werden und Null und negative Zahlen umfassen:

subtract_test01 = Counter("AAB")
subtract_test01.subtract("BCC")
print(subtract_test01)  #Counter({'A': 2, 'B': 0, 'C': -2})

5. Wörterbuchmethoden

Normalerweise können Wörterbuchmethoden für Zählerobjekte verwendet werden, außer dass es zwei Methoden gibt, die anders funktionieren als Wörterbücher.

fromkeys(iterable): Diese Klassenmethode ist in Counter nicht implementiert.

• update([iterable-or-mapping]): Elemente aus dem iterierbaren Objekt zählen oder aus einem anderen Mapping-Objekt (oder Zähler) hinzufügen, die Anzahl der Elemente wird hinzugefügt. Darüber hinaus sollte das Iterationsobjekt ein Sequenzelement und kein (Schlüssel-Wert-)Paar sein.

• subtract_test02 = Counter("which")
  subtract_test02.subtract("witch")  #从另一个迭代序列中减去元素
  subtract_test02.subtract(Counter("watch"))  #^……
   
  #查看结果
  print( subtract_test02["h"] )  # 0 ,whirch 中两个，减去witch中一个，减去watch中一个，剩0个
  print( subtract_test02["w"] )  #-1

  6. Mathematische Operationen

Diese Funktion ist sehr leistungsfähig und bietet mehrere mathematische Operationen, die mit Counter-Objekten kombiniert werden können, um Multisets (Elemente größer als 0 im Zähler) zu erzeugen. Addition und Subtraktion kombinieren Zähler, indem sie die entsprechende Anzahl von Elementen addieren oder subtrahieren. Schnittpunkt und Vereinigung geben den minimalen bzw. maximalen Wert der entsprechenden Anzahl zurück. Jede Operation akzeptiert vorzeichenbehaftete Zählungen, aber die Ausgabe ignoriert Zählungen, deren Ergebnis Null oder kleiner als Null ist.

sum(c.values())                 # total of all counts
c.clear()                       # reset all counts
list(c)                         # list unique elements
set(c)                          # convert to a set
dict(c)                         # convert to a regular dictionary
c.items()                       # convert to a list of (elem, cnt) pairs
Counter(dict(list_of_pairs))    # convert from a list of (elem, cnt) pairs
c.most_common(n)                   # n least common elements
+c                              # remove zero and negative counts

c = Counter(a=3, b=1)
d = Counter(a=1, b=2)
c + d                       # add two counters together:  c[x] + d[x]
Counter({'a': 4, 'b': 3})
c - d                       # subtract (keeping only positive counts)
Counter({'a': 2})
c & d                       # intersection:  min(c[x], d[x]) 
Counter({'a': 1, 'b': 1})
c | d                       # union:  max(c[x], d[x])
Counter({'a': 3, 'b': 2})

und „und „oder“-Operationen:

print(Counter('AAB') + Counter('BCC'))
#Counter({'B': 2, 'C': 2, 'A': 2})
print(Counter("AAB")-Counter("BCC"))
#Counter({'A': 2})

unäre Addition und Subtraktion (unäre Operatoren) bedeutet Addition oder Subtraktion vom leeren Zähler, was einer Multiplikation des Zählwerts mit einem positiven oder negativen Wert entspricht, die gleiche Ausgabe Zählungen ignorieren, deren Ergebnisse Null oder kleiner als Null sind:

print(Counter('AAB') & Counter('BBCC'))
#Counter({'B': 1})
 
print(Counter('AAB') | Counter('BBCC'))
#Counter({'A': 2, 'C': 2, 'B': 2})

Schreiben Sie einen Algorithmus zur Berechnung der Textähnlichkeit und der gewichteten Ähnlichkeit:

c = Counter(a=2, b=-4)
+c
Counter({'a': 2})
-c
Counter({'b': 4})

7. Berechnen Sie die Gesamtzahl der Elemente, Keys() und Values()

def str_sim(str_0,str_1,topn):
    topn = int(topn)
    collect0 = Counter(dict(Counter(str_0).most_common(topn)))
    collect1 = Counter(dict(Counter(str_1).most_common(topn)))       
    jiao = collect0 & collect1
    bing = collect0 | collect1       
    sim = float(sum(jiao.values()))/float(sum(bing.values()))        
    return(sim)         

str_0 = '定位手机定位汽车定位GPS定位人定位位置查询'         
str_1 = '导航定位手机定位汽车定位GPS定位人定位位置查询'         

str_sim(str_0,str_1,5)    
0.75

8 Einzelelementergebnisse

from collections import Counter
 
c = Counter('ABCABCCC')
print(sum(c.values()))  # 8  total of all counts
 
print(c.keys())  #dict_keys(['A', 'B', 'C'])
print(c.values())  #dict_values([2, 2, 4])

10. Update update()

from collections import Counter
c = Counter('ABBCC')
#查询具体某个元素的个数
print(c["A"])  #1

3. Wird hauptsächlich zum Zählen der Häufigkeit von Objekten verwendet, auf die Sie zugreifen.

elements(): Gibt einen Iterator zurück, die Anzahl der wiederholten Berechnungen für jedes Element sei Ignorieren.

most_common([n]): Gibt eine Liste mit den n am häufigsten aufgerufenen Elementen und der Anzahl zurück.

subtract([iterable-or-mapping]): Subtrahiert Elemente vom iterierbaren Objekt, der Eingabe und die Ausgabe kann 0 oder negativ sein, was sich von der Rolle des Minuszeichens unterscheidet –

update([iterable-or-mapping]): Elemente aus einem iterierbaren Objekt zählen oder aus einem anderen Mapping-Objekt (oder Zähler) hinzufügen

• .
Beispiel:

• for elem in 'ADD':  # update counts from an iterabl
      c[elem] += 1
  print(c.most_common())  #[('C', 2), ('D', 2), ('A', 2), ('B', 2)]
  #可以看出“A”增加了一个，新增了两个“D”

  Häufig verwendete Methode:

  del c["D"]
  print(c.most_common())  #[('C', 2), ('A', 2), ('B', 2)]
  del c["C"]
  print(c.most_common())  #[('A', 2), ('B', 2)]

Das obige ist der detaillierte Inhalt vonPython-Zähler: Wie verwende ichcollections.Counter?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!