Description

Project	Description
Python Interpreter	3.10. 6

Counter module

In Python’s collections module, a very commonly used module is Counter. Counter is a simple counter used to count the number of certain hashable objects. It stores elements and their counts in the form of a dictionary.

Counter() class

ClassCounter() can count the parameters passed to this class according to certain rules, and use the counting object and the counting result as the key The value pairs are returned in the form of a dictionary.

Counter(iterable=None, /, **kwds)

Give a chestnut

from collections import Counter
# 返回一個(gè)空的 Counter 對象
cnt = Counter()
print(cnt)

# 將可迭代對象（字符串）作為參數(shù)
cnt = Counter('Hello World')
print(cnt)

# 將可迭代對象（列表）作為參數(shù)
cnt = Counter(['a', 'a', 'b', 'd', 'c', 'd'])
print(cnt)

# 使用可迭代對象（字典）作為參數(shù)
cnt = Counter({'a': 1, 'b': 2, 'd': 3, 'c': 2})
print(cnt)

# 使用關(guān)鍵字參數(shù)
cnt = Counter(a=1, b=2, d=3, c=2)
print(cnt)

Execution effect

Counter()
Counter({' l': 3, 'o': 2, 'H': 1, 'e': 1, ' ': 1, 'W': 1, 'r': 1, 'd': 1})
Counter({'a': 2, 'd': 2, 'b': 1, 'c': 1})
Counter({'d': 3, 'b': 2, 'c': 2, 'a': 1})
Counter({'d': 3, 'b': 2, 'c': 2, 'a': 1})

Counter () Object

Dictionary

The result returned by Counter() is a dictionary, which has most of the methods of an ordinary dictionary. In most cases, you can operate Counter objects just like dictionaries. For this, please refer to the following example:

from collections import Counter
cnt = Counter('Hello World')
print(cnt)

# 輸出 Counter 對象中的鍵值對列表
print(cnt.items())

# 移除 Counter 對象中的最后一個(gè)鍵值對
print(cnt.popitem())
print(cnt)

# 輸出 Counter 中鍵 l 對應(yīng)的值
print(cnt['l'])

Execution result

Counter({'l': 3, 'o': 2, 'H' : 1, 'e': 1, ' ': 1, 'W': 1, 'r': 1, 'd': 1})
dict_items([('H', 1), ('e ', 1), ('l', 3), ('o', 2), (' ', 1), ('W', 1), ('r', 1), ('d', 1 )])
('d', 1)
Counter({'l': 3, 'o': 2, 'H': 1, 'e': 1, ' ': 1, 'W ': 1, 'r': 1})
3

Ordering

Dictionaries in Python are unordered,Unordered## The meaning of # does not mean that the key-value pairs in the dictionary have no order, but that the order of the key-value pairs in the dictionary is unpredictable. For this, please refer to the following example:

d = {'a': 1, 'b': 2, 'c': 3}
for key in d:
    print(key)

The output of this example may be:

a

b
c

It may also be :

b

c
a

Of course there are other possibilities, so I won’t list them all here.

Python has officially optimized the dictionary in the

Python 3.6 version so that it can remember the order in which key-value pairs are inserted. After this, the dictionary looks less cluttered (the order of key-value pairs in the dictionary becomes predictable).

KeyError

In Python's built-in dictionary, if you try to access a key that does not exist, Python will throw a

KeyError exception error. For this, please refer to the following example:

d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)

# 嘗試訪問字典 d 中不存在的鍵
print(d['d'])

Execution effect

Traceback (most recent call last):

File "C:\main. py", line 5, in
print(d['d'])
KeyError: 'd'
{'a': 1, 'b': 2, 'c' : 3}

Same scene. This time, we have Counter as the protagonist.

from collections import Counter
cnt = Counter({'a': 1, 'b': 2, 'c': 3})
print(cnt)

# 嘗試訪問 Counter 中不存在的鍵
print(cnt['d'])

Execution effect

When accessing a key that does not exist in the Counter object, the

KeyError exception will not be thrown, but Returns the default count value 0.

Counter({'c': 3, 'b': 2, 'a': 1})

0

Magic method__missing__

__missing__() is a special method in Python used to handle the situation when the key does not exist when accessing the value in the dictionary by key. When we use a dictionary index to access a key that does not exist, Python will call the special method
__missing__() to try to return a suitable value. If the __missing__() method is not implemented, Python will throw a KeyError exception. For this, please refer to the following example:

# 創(chuàng)建一個(gè)字典對象，該對象繼承自 Python 內(nèi)置的 dict 對象
class MyDict(dict):
    def __missing__(self, key):
        return 0

# 實(shí)例化 MyDict() 對象
myDict = MyDict()
# 嘗試訪問 myDict 對象中不存在的鍵 a
print(myDict['a'])

Execution effect

0

update() method

# The

##Counter

object and the dict object also implement the update() method. Use the update() method to merge the dictionary as a parameter into the dict object that calls the method. The difference is that when the update() method of the dict object encounters the same key, it will perform the overwrite operation on the value corresponding to the key. When the update() method of the Counter object encounters the same key, it will perform the overlay operation on the value corresponding to the key. For this, please refer to the following example:

from collections import Counter
# Python 中內(nèi)置的 dict 對象
d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)

d.update({'a': 4})
print(d)

print()

# Counter 對象
cnt = Counter({'a': 1, 'b': 2, 'c': 3})
print(cnt)

cnt.update({'a': 4})
print(cnt)

Execution effect

{'a': 1, 'b': 2, 'c': 3 }

{'a': 4, 'b': 2, 'c': 3}

Counter({'c': 3, 'b': 2, 'a': 1} )

Counter({'a': 5, 'c': 3, 'b': 2})

Counter 對象的常用方法

most_common()

most_common() 方法將返回一個(gè)列表，列表中的元素均為 Counter 對象中的鍵值對組成的元組。元組在列表中的順序取決于計(jì)數(shù)值（鍵值對中的值）的大小。計(jì)數(shù)值更大的元組將位于列表的前端，計(jì)數(shù)值相等的元組將按照它們首次在列表中出現(xiàn)的順序進(jìn)行排列（先出現(xiàn)的元組將更靠近列表的前端）。
most_common() 默認(rèn)將使用 Counter 對象中所有的鍵值對組成的元組作為返回列表中的元素。你可以通過向該方法提供一個(gè)數(shù)值，該數(shù)值將指定放回的列表中的元素的數(shù)量。

舉個(gè)栗子

from collections import Counter
cnt = Counter({'a': 1, 'b': 2, 'c': 3})
print(cnt)

print()

print(cnt.most_common())
# 返回由 Counter 中計(jì)數(shù)值最大的兩個(gè)
# 鍵值對構(gòu)成的元組所組成的列表
print(cnt.most_common(2))
# 返回由 Counter 中計(jì)數(shù)值最大的
# 鍵值對構(gòu)成的元組所組成的列表
print(cnt.most_common(1))

執(zhí)行效果

Counter({'c': 3, 'b': 2, 'a': 1})

[('c', 3), ('b', 2), ('a', 1)]
[('c', 3), ('b', 2)]
[('c', 3)]

elements()

elements() 方法將返回一個(gè)以 Counter 對象中的鍵為元素的迭代器，其中每個(gè)元素將重復(fù)出現(xiàn)計(jì)數(shù)值所指定的次數(shù)。

迭代器中的元素將存在如下特點(diǎn)：

• 元素將會(huì)按照其首次添加到 Counter 對象中的順序進(jìn)行返回。

• 某個(gè)鍵對應(yīng)的計(jì)數(shù)值小于一，那么該鍵將不會(huì)作為元素出現(xiàn)在 element() 方法返回的迭代器中。

舉個(gè)栗子

from collections import Counter
cnt = Counter({'a': 1, 'b': 2, 'c': 3, 'd': -4})
print(cnt)

print()

print(list(cnt.elements()))

執(zhí)行效果

Counter({'c': 3, 'b': 2, 'a': 1, 'd': -4})

['a', 'b', 'b', 'c', 'c', 'c']

total()

total() 方法將返回 Counter 對象中，所有計(jì)數(shù)值累加后得到的結(jié)果。對此，請參考如下示例：

from collections import Counter
cnt = Counter({'a': 1, 'b': 2, 'c': 3, 'd': -4})
cnt1 = Counter('Hello World')
print(cnt.total())
print(cnt1.total())

執(zhí)行效果

2
11

subtract()

該方法的效果與 Counter 對象的 update() 方法類似。如果說 update() 方法執(zhí)行的是 加 操作，那么 subtract() 方法執(zhí)行的則是 減 操作。對此，請參考如下示例：

from collections import Counter
cnt = Counter({'a': 1, 'b': 2, 'c': 3, 'd': -4})

cnt.subtract({'a': 0, 'b': 1, 'd': -11})
print(cnt)

執(zhí)行效果

Counter({'d': 7, 'c': 3, 'a': 1, 'b': 1})

Counter 對象間的運(yùn)算

注：

本部分內(nèi)容中講解到的運(yùn)算符僅能在 Python 3.3 及以后版本中正常使用。

加法運(yùn)算

在 Python 的 Counter 模塊中，兩個(gè) Counter 對象可以相加，相加后將返回一個(gè)新的 Counter 對象，其中每個(gè)元素的計(jì)數(shù)是兩個(gè)原始 Counter 對象中該元素計(jì)數(shù)的總和。可以通過使用加法運(yùn)算符來執(zhí)行此操作。對此，請參考如下示例：

from collections import Counter

cnt = Counter('Hello')
cnt1 = Counter('World')

print(cnt)
print(cnt1)
print(cnt + cnt1)

執(zhí)行效果

Counter({'l': 2, 'H': 1, 'e': 1, 'o': 1})
Counter({'W': 1, 'o': 1, 'r': 1, 'l': 1, 'd': 1})
Counter({'l': 3, 'o': 2, 'H': 1, 'e': 1, 'W': 1, 'r': 1, 'd': 1})

注：

在 Counter 對象間的運(yùn)算過程中，對于 Counter 中不存在的鍵，其計(jì)數(shù)值為零。

減法運(yùn)算

在 Python 的 Counter 模塊中，可以使用減法運(yùn)算符來對兩個(gè) Counter 對象進(jìn)行減法運(yùn)算，即將左側(cè) Counter 對象中的計(jì)數(shù)器值減去右側(cè) Counter 對象中相同鍵的計(jì)數(shù)器值，最后返回一個(gè)新的 Counter 對象。對此，請參考如下示例：

from collections import Counter

cnt = Counter('cook')
cnt1 = Counter('coder')

print(cnt)
print(cnt1)
print(cnt - cnt1)

執(zhí)行效果

Counter({'o': 2, 'c': 1, 'k': 1})
Counter({'c': 1, 'o': 1, 'd': 1, 'e': 1, 'r': 1})
Counter({'o': 1, 'k': 1})

注：

在 Counter 對象間的運(yùn)算過程中，對于 Counter 中不存在的鍵，其計(jì)數(shù)值為零。

并集運(yùn)算

Counter 對象之間的并集運(yùn)算是指兩個(gè) Counter 對象按照鍵的并集進(jìn)行運(yùn)算，返回的結(jié)果是一個(gè)新的 Counter 對象，其中包含的鍵和值均為 原始 Counter 對象中存在的鍵及其對應(yīng)的最大值。對此，請參考如下示例：

from collections import Counter

cnt = Counter('Hello')
cnt1 = Counter('World')

print(cnt)
print(cnt1)
print(cnt | cnt1)

執(zhí)行效果

Counter({'l': 2, 'H': 1, 'e': 1, 'o': 1})
Counter({'W': 1, 'o': 1, 'r': 1, 'l': 1, 'd': 1})
Counter({'l': 2, 'H': 1, 'e': 1, 'o': 1, 'W': 1, 'r': 1, 'd': 1})

交集運(yùn)算

Counter 對象之間的交集運(yùn)算是指兩個(gè) Counter 對象按照鍵的交集進(jìn)行運(yùn)算，返回的結(jié)果是一個(gè)新的 Counter 對象，其中包含的鍵和值均為 原始 Counter 對象中共同擁有的鍵及其對應(yīng)的最小值。對此，請參考如下示例：

from collections import Counter

cnt = Counter('Hello')
cnt1 = Counter('World')

print(cnt)
print(cnt1)
print(cnt & cnt1)

執(zhí)行效果

Counter({'l': 2, 'H': 1, 'e': 1, 'o': 1})
Counter({'W': 1, 'o': 1, 'r': 1, 'l': 1, 'd': 1})
Counter({'l': 1, 'o': 1})

單目運(yùn)算

單目運(yùn)算指的是表達(dá)式中存在單目運(yùn)算符的運(yùn)算操作。存在兩種單目運(yùn)算符，即單目減法運(yùn)算符與單目加法運(yùn)算符。無論是單目減法運(yùn)算符還是單目加法運(yùn)算符，它們的操作對象均為 Counter 對象中的計(jì)數(shù)值。
在對 Counter 對象進(jìn)行單目運(yùn)算后，將返回一個(gè)由大于零的計(jì)數(shù)值相關(guān)的鍵值對組成的 Counter 對象。對此，請參考如下示例：

from collections import Counter

cnt = Counter({'a': 4, 'b': 3, 'd': 0, 'c': -5})
print(+cnt)
print(-cnt)

執(zhí)行效果

Counter({'a': 4, 'b': 3})
Counter({'c': 5})

Counter 對象間的比較

從 Python 3.10 版本開始，Counter 對象間開始支持常見的比較運(yùn)算符，這些運(yùn)算符有：

• <

• <=

• >

• >=

• ==

• !=

這里以 > 及 == 為例進(jìn)行講解。

>

當(dāng) > 的左側(cè)的 Counter 對象的鍵對應(yīng)的計(jì)數(shù)值均大于該符號(hào)右側(cè)的 Counter 對象中相同的鍵（對于 Counter 中不存在的鍵，其計(jì)數(shù)值為零）對應(yīng)的計(jì)數(shù)值時(shí)，比較結(jié)果為 True。否則為 False。對此，請參考如下示例：

from collections import Counter

cnt = Counter({'a': 4, 'b': 3, 'd': 7, 'c': 5})
cnt1 = Counter({'c': 3, 'd': 2, 'b': 6, 'a': 4})
cnt2 = Counter({'c': 4, 'd': 6, 'b': 2, 'a': 3})

print(cnt > cnt1)
print(cnt > cnt2)

執(zhí)行效果

False
True

==

當(dāng) == 的左側(cè)的 Counter 對象的鍵對應(yīng)的計(jì)數(shù)值均等于該符號(hào)右側(cè)的 Counter 對象中相同的鍵（對于 Counter 中不存在的鍵，其計(jì)數(shù)值為零）對應(yīng)的計(jì)數(shù)值時(shí)，比較結(jié)果為 True。否則為 False。對此，請參考如下示例：

from collections import Counter

cnt = Counter({'a': 3, 'b': 2, 'd': 6, 'c': 4})
cnt1 = Counter({'c': 3, 'd': 2, 'b': 6, 'a': 4})
cnt2 = Counter({'c': 4, 'd': 6, 'b': 2, 'a': 3})

print(cnt == cnt1)
print(cnt == cnt2)

執(zhí)行效果

False
True

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