Compteurs Python : Comment utiliser collections.Counter ?

1. Introduction

Un outil de compteur permet un comptage rapide et pratique. Counter est une sous-classe de dict, utilisée pour compter les objets hachables. Il s'agit d'une collection avec des éléments stockés comme des clés de dictionnaire et leurs comptes comme valeurs. Les comptes peuvent être n'importe quelle valeur entière, y compris 0 et des nombres négatifs, et la classe Counter ressemble un peu à des sacs ou à des multisets dans d'autres langages. Pour faire simple, cela peut être compté statistiquement. Jetons un coup d’œil à quelques exemples pour que ce soit clair.
Exemple :

#计算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}

Les éléments sont comptés à partir d'un itérable ou initialisés à partir d'un autre mappage (ou compteur) :

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 Opérations de base

1. Comptez le nombre d'occurrences de chaque élément dans la "séquence itérable"

1.1. Effet sur la liste/chaîne

Voici deux façons de l'utiliser, l'une consiste à l'utiliser directement et l'autre à l'utiliser après instanciation. Si vous souhaitez l'appeler fréquemment, cette dernière est évidemment plus concise, car. vous pouvez facilement appeler Counter. Les différentes méthodes sont les mêmes pour les autres séquences itérables.

#首先引入该方法
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 Résultats de sortie

#查看类型
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 Utilisez la méthode items() intégrée pour afficher

Évidemment, cette méthode est plus pratique que de convertir en dictionnaire puis de le sortir :

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. occurrences fréquentes Element

utilise la méthode most_common() pour renvoyer une liste contenant les n éléments les plus courants et leur nombre d'occurrences, triés par fréquence de haut en bas. Si n est omis ou None, most_common() renverra tous les éléments du compteur. Les éléments avec des valeurs de nombre égales sont triés dans l'ordre de première apparition. Mots souvent utilisés pour calculer la fréquence des mots les plus élevés :

#求序列中出现次数最多的元素
 
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)]

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

3. ) et sort ()Method

Description : renvoie un itérateur dans lequel chaque élément sera répété le nombre de fois spécifié par la valeur de comptage. Les éléments sont renvoyés par ordre de première occurrence. Si le nombre d'un élément est inférieur à 1, elements() l'ignorera.
Exemple :

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

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

Exemple de document officiel :

# 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

4. Opération de soustraction subtract() : la sortie n'ignorera pas le nombre dont le résultat est zéro ou inférieur à zéro

Soustrait les éléments de l'objet itératif ou de l'objet de mappage, tous deux entrés. et la sortie peut être 0 ou négative.

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}

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

Le nombre ici peut être réduit à zéro et peut inclure des nombres nuls et négatifs :

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

5. Méthodes de dictionnaire

Habituellement, les méthodes de dictionnaire peuvent être utilisées sur les objets Counter, sauf qu'il existe deux méthodes qui fonctionnent différemment des dictionnaires.

• fromkeys(iterable) : Cette méthode de classe n'est pas implémentée dans Counter.

• update([iterable-or-mapping]) : Comptez les éléments de l'objet itérable ou ajoutez à partir d'un autre objet de mappage (ou compteur), le nombre d'éléments est ajouté. De plus, l'objet d'itération doit être un élément de séquence et non une paire (clé, valeur).

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

6. Opérations mathématiques

Cette fonction est très puissante et fournit plusieurs opérations mathématiques qui peuvent être combinées avec des objets Counter pour produire des multisets (éléments supérieurs à 0 dans le compteur). L'addition et la soustraction combinent des compteurs en ajoutant ou en soustrayant le nombre d'éléments correspondant. L'intersection et l'union renvoient la valeur minimale ou maximale du nombre correspondant. Chaque opération accepte les décomptes signés, mais la sortie ignore les décomptes dont le résultat est nul ou inférieur à zéro.

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

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

et opérations "et" ou :

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

l'addition et la soustraction unaires (opérateurs unaires) signifient ajouter ou soustraire du compteur vide, ce qui équivaut à multiplier la valeur de comptage par une valeur positive ou négative, le même résultat sera Ignorez les comptes dont les résultats sont nuls ou inférieurs à zéro :

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

Écrivez un algorithme pour calculer la similarité du texte, la similarité pondérée :

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

7 Calculez le nombre total d'éléments, Keys() et Values()

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

8. résultats d'un seul élément

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

9. Ajouter

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”

10. Supprimer(del)

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

11 Mettre à jour la mise à jour()

d = Counter("CCDD")
c.update(d)
print(c.most_common())  #[('B', 2), ('A', 2), ('C', 2), ('D', 2)]

12. principalement utilisé pour compter la fréquence des objets auxquels vous accédez.

Méthodes courantes :

elements() : renvoie un itérateur, le nombre de calculs répétés pour chaque élément. Si le nombre d'un élément est inférieur à 1, il le sera. be Ignore.

• most_common([n]) : renvoie une liste fournissant les n éléments et le nombre les plus fréquemment consultés

• subtract([iterable-or-mapping]) : soustrait les éléments de l'objet itérable, l'entrée. et la sortie peut être 0 ou négative, ce qui est différent du rôle du signe moins -

• update([iterable-or-mapping]) : compter les éléments d'un objet itérable ou ajouter à partir d'un autre objet de mappage (ou compteur)

• Exemple :

  c.clear()
  print(c)  #Counter()

Méthode couramment utilisée :

# 统计字符出现的次数
>>> import collections
>>> collections.Counter('hello world')
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
# 统计单词数
>>> collections.Counter('hello world hello world hello nihao'.split())
Counter({'hello': 3, 'world': 2, 'nihao': 1})

.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!