Python計數器collections.Counter怎么使用

這篇文章主要介紹“Python計數器collections.Counter怎么使用”，在日常操作中，相信很多人在Python計數器collections.Counter怎么使用問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Python計數器collections.Counter怎么使用”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

一. 介紹

一個計數器工具提供快速和方便的計數，Counter是一個dict的子類，用于計數可哈希對象。它是一個集合，元素像字典鍵(key)一樣存儲，它們的計數存儲為值。計數可以是任何整數值，包括0和負數，Counter類有點像其他語言中的bags或multisets。簡單說，就是可以統計計數，來幾個例子看看就清楚了。
舉例：

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

元素從一個iterable 被計數或從其他的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})

二. 基本操作

1. 統計“可迭代序列”中每個元素的出現的次數

1.1 對列表/字符串作用

下面是兩種使用方法，一種是直接使用，一種是實例化以后使用，如果要頻繁調用的話，顯然后一種更簡潔 ，因為可以方便地調用Counter內的各種方法，對于其他可迭代序列也是一樣的套路。

#首先引入該方法
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 輸出結果

#查看類型
print( type(temp) ) #<class 'collections.Counter'>
 
#轉換為字典后輸出
print( dict(temp) ) #{'b': 4, 'a': 5, 'c': 3, 'd': 2, 'e': 1}
 
for num,count in enumerate(dict(temp).items()):
    print(count)
"""
('e', 1)
('c', 3)
('a', 5)
('b', 4)
('d', 2)
"""

1.3 用自帶的items()方法輸出

顯然這個方法比轉換為字典后再輸出的方法更為方便：

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()統計出現次數最多的元素

利用most_common()方法，返回一個列表，其中包含n個最常見的元素及出現次數，按常見程度由高到低排序。 如果 n 被省略或為None，most_common() 將返回計數器中的所有元素，計數值相等的元素按首次出現的順序排序，經常用來計算top詞頻的詞語：

#求序列中出現次數最多的元素
 
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() 和 sort()方法

描述：返回一個迭代器，其中每個元素將重復出現計數值所指定次。 元素會按首次出現的順序返回。 如果一個元素的計數值小于1，elements() 將會忽略它。
舉例：

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())) #['A', 'A', 'C', 'C', 'C', 'C', 'B', 'B']
 
#或者這種方式
print(sorted(c.elements()))  #['A', 'A', 'B', 'B', 'C', 'C', 'C', 'C']
 
#這里與sorted的作用是： list all unique elements，列出所有唯一元素
#例如
print( sorted(c) ) #['A', 'B', 'C']

官方文檔例子：

# 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()減操作：輸出不會忽略掉結果為零或者小于零的計數

從迭代對象或映射對象減去元素，輸入和輸出都可以是0或者負數。

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

這里的計數可以減到零一下，可以包含零和負數：

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. 字典方法

通常字典方法都可用于Counter對象，除了有兩個方法工作方式與字典并不相同。

• fromkeys(iterable)：這個類方法沒有在Counter中實現。

• update([iterable-or-mapping])：從迭代對象計數元素或者從另一個映射對象 (或計數器) 添加，元素個數是加上。另外迭代對象應該是序列元素，而不是一個 (key, value) 對。

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. 數學操作

這個功能非常強大，提供了幾個數學操作，可以結合 Counter 對象，以生產 multisets (計數器中大于0的元素）。 加和減，結合計數器，通過加上或者減去元素的相應計數。交集和并集返回相應計數的最小或最大值。每種操作都可以接受帶符號的計數，但是輸出會忽略掉結果為零或者小于零的計數。

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

與”和“或”操作:

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

單目加和減（一元操作符）意思是從空計數器加或者減去，相當于給計數值乘以正值或負值，同樣輸出會忽略掉結果為零或者小于零的計數:

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

寫一個計算文本相似的算法，加權相似：

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. 計算元素總數、Keys() 和 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. 查詢單元素結果

from collections import Counter
c = Counter('ABBCC')
#查詢具體某個元素的個數
print(c["A"])  #1

9. 添加

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. 刪除（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()

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

12. 清除 clear()

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

三. 總結

Counter是一個dict子類，主要是用來對你訪問的對象的頻率進行計數。

常用方法：

• elements()：返回一個迭代器，每個元素重復計算的個數，如果一個元素的計數小于1,就會被忽略。

• most_common([n])：返回一個列表，提供n個訪問頻率最高的元素和計數

• subtract([iterable-or-mapping])：從迭代對象中減去元素，輸入輸出可以是0或者負數，不同于減號 - 的作用

• update([iterable-or-mapping])：從迭代對象計數元素或者從另一個 映射對象 (或計數器) 添加。

舉例：

# 統計字符出現的次數
>>> 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})

常用的方法：

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

到此，關于“Python計數器collections.Counter怎么使用”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！