Python Counters: How to use collections.Counter?

1. Introduction

A counter tool provides fast and convenient counting. Counter is a subclass of dict, used to count hashable objects. It is a collection with elements stored like dictionary keys and their counts as values. Counts can be any integer value, including 0 and negative numbers, and the Counter class is a bit like bags or multisets in other languages. To put it simply, it can be counted statistically. Let’s take a look at a few examples to make it clear.
Example:

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

Elements are counted from an iterable or initialized from other mapping (or counter):

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. Basic operations

1. Statistics" The number of occurrences of each element in iterable sequence"

1.1 Effect on list/string

The following are two ways to use it, one is to use it directly, and the other is to instantiate it If you want to call it frequently, obviously the latter one is more concise, because you can easily call various methods in Counter, and the same routine is used for other iterable sequences.

#首先引入该方法
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 Output results

#查看类型
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 Use the built-in items() method to output

Obviously this method is more convenient than converting to a dictionary and then outputting it:

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. most_common() counts the elements with the most occurrences

Use the most_common() method to return a list containing the n most common elements and the number of occurrences, in order of commonness Sort to low. If n is omitted or None, most_common() will return all elements in the counter. Elements with equal count values ​​are sorted in the order of first appearance. Words often used to calculate top word frequency:

#求序列中出现次数最多的元素
 
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. elements () and sort() methods

Description: Returns an iterator in which each element will be repeated the number of times specified by the count value. Elements are returned in order of first occurrence. If an element's count is less than 1, elements() will ignore it.
Example:

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

Official document example:

# 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. subtract() subtraction operation: the output will not ignore the count whose result is zero or less than zero

Subtract elements from an iterable or mapped object. Both input and output can be 0 or negative.

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

The count here can be reduced to zero and can include zero and negative numbers:

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. Dictionary method

Usually dictionary methods can be used for Counter objects, except There are two methods that work differently than dictionaries.

• fromkeys(iterable): This class method is not implemented in Counter.

• update([iterable-or-mapping]): Count elements from the iterable object or add from another mapping object (or counter), the number of elements is added. In addition, the iteration object should be a sequence element, not a (key, value) pair.

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. Mathematical operations

This function is very powerful and provides several mathematical operations that can be combined with Counter objects to produce multisets (elements greater than 0 in the counter ). Addition and subtraction combine counters by adding or subtracting the corresponding count of elements. Intersection and union return the minimum or maximum value of the corresponding count. Each operation accepts signed counts, but the output ignores counts whose result is zero or less than zero.

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

And" and "OR" operations:

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

Unidirectional addition and subtraction (unary operators) means adding or subtracting from the empty counter, which is equivalent to multiplying the count value by positive Value or negative value, the output will also ignore the count whose result is zero or less than zero:

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

Write an algorithm to calculate text similarity, weighted similarity:

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. Calculate the total number of elements, Keys() and 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. Query single element results

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

9. Add

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. Delete (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. Update update()

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

12. Clear clear()

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

3. Summary

Counter is a dict subclass, mainly used to access you The frequency of objects is counted.

Commonly used methods:

• elements(): Returns an iterator, the number of repeated calculations for each element, if the count of an element If it is less than 1, it will be ignored.

• most_common([n]): Returns a list providing the n most frequently accessed elements and their count

• subtract([iterable-or-mapping]): Subtract elements from the iterable object. The input and output can be 0 or negative numbers, which is different from the role of the minus sign -

• update ([iterable-or-mapping]): Count elements from an iterable object or add from another mapping object (or counter).

Example:

# 统计字符出现的次数
>>> 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})

Commonly used Method:

>>> c = collections.Counter('hello world hello world hello nihao'.split())
>>> c
Counter({'hello': 3, 'world': 2, 'nihao': 1})
# 获取指定对象的访问次数，也可以使用get()方法
>>> c['hello']
3
>>> c = collections.Counter('hello world hello world hello nihao'.split())
# 查看元素
>>> list(c.elements())
['hello', 'hello', 'hello', 'world', 'world', 'nihao']
# 追加对象，或者使用c.update(d)
>>> c = collections.Counter('hello world hello world hello nihao'.split())
>>> d = collections.Counter('hello world'.split())
>>> c
Counter({'hello': 3, 'world': 2, 'nihao': 1})
>>> d
Counter({'hello': 1, 'world': 1})
>>> c + d
Counter({'hello': 4, 'world': 3, 'nihao': 1})
# 减少对象，或者使用c.subtract(d)
>>> c - d
Counter({'hello': 2, 'world': 1, 'nihao': 1})
# 清除
>>> c.clear()
>>> c
Counter()

The above is the detailed content of Python Counters: How to use collections.Counter?. For more information, please follow other related articles on the PHP Chinese website!