一、collections.Counter()的基本用法

在Python中，collections.Counter()是一个用于计数可哈希对象的工具类。它是collections模块中的一部分，提供了方便的计数功能。

Counter对象可以用来计算可迭代对象中元素的出现次数，并以字典的形式返回结果，其中元素作为键，出现次数作为值。它可以接受任何可哈希的对象作为输入，例如字符串、列表、元组等。

下面是一个简单的示例，展示了如何使用Counter类：

# 导入collections模块
from collections import Counter

s = "abacba"

# 创建一个Counter对象
hash = Counter(s)

# 输出元素出现次数
print(hash)  # 输出: Counter({'a': 3, 'b': 2, 'c': 1})

# 访问特定元素的计数
print(hash['a'])  # 输出: 3
print(hash['b'])  # 输出: 2
print(hash['c'])  # 输出: 1

# 更新计数
hash['a'] += 1
print(hash['a'])  # 输出: 4

二、常见的其他用法

此外Counter还提供了许多其他有用的方法，例如计算多个Counter对象的并集、交集、差集等操作，以及支持算术运算符（如加法、减法）进行计数操作。通过使用Counter，可以轻松地统计数据中元素的出现次数，并进行各种计数相关的操作。

一个简单的示例来展示Counter对象的加法和减法：

# 俩collections的加减法
ransomNote = "aaaaaaaab"
magazine = "abb"

# 创建俩个Counter对象a和b
a = Counter(ransomNote)
b = Counter(magazine)

print(a)  # 输出Counter({'a': 8, 'b': 1})
print(b)  # 输出Counter({'a': 1,'b': 2 })

print(a - b)  # 得到Counter({'a': 7})
print(a + b)  # Counter({'a': 9, 'b': 3})

collections.Counter()提供了一些方法来计算多个Counter对象之间的并集、交集和差集。下面是每种操作的具体示例：

1. 并集（Union）：使用+运算符或update()方法可以计算两个Counter对象的并集。

from collections import Counter

c1 = Counter({'a': 3, 'b': 2, 'c': 1})
c2 = Counter({'a': 2, 'b': 2, 'd': 1})

# 使用 + 运算符计算并集
union1 = c1 + c2
print(union1)  # 输出: Counter({'a': 5, 'b': 4, 'c': 1, 'd': 1})

# 使用 update() 方法计算并集
c1.update(c2)
print(c1)  # 输出: Counter({'a': 5, 'b': 4, 'c': 1, 'd': 1})

2. 交集（Intersection）：使用&运算符可以计算两个Counter对象的交集。

from collections import Counter

c1 = Counter({'a': 3, 'b': 2, 'c': 1})
c2 = Counter({'a': 2, 'b': 2, 'd': 1})

intersection = c1 & c2
print(intersection)  # 输出: Counter({'a': 2, 'b': 2})

3. 差集（Difference）：使用-运算符可以计算两个Counter对象的差集。

from collections import Counter

c1 = Counter({'a': 3, 'b': 2, 'c': 1})
c2 = Counter({'a': 2, 'b': 2, 'd': 1})

difference = c1 - c2
print(difference)  # 输出: Counter({'a': 1, 'c': 1})

需要注意的是，这些操作返回的结果都是Counter对象，其中包含了计算后的元素及其对应的计数。

此外， Counter().most_common() 是 Counter 类中的一个方法，用于返回计数对象中出现次数最多的元素及其计数。它以列表的形式返回结果，其中每个元素是一个包含元素和计数的元组。

下面是一个示例：

from collections import Counter

c = Counter(['a', 'b', 'a', 'c', 'b', 'a'])

print(c.most_common())  # 输出: [('a', 3), ('b', 2), ('c', 1)]
print(c.most_common(1))  # 输出:[('a', 3)]
print(c.most_common(2))  # 输出:[('a', 3), ('b', 2)]
print(c.most_common(3))  # 输出:[('a', 3), ('b', 2), ('c', 1)]

在上述示例中，我们创建了一个计数对象 c，其中包含了一些元素的出现次数。然后，我们调用 most_common() 方法获取出现次数最多的元素及其计数。返回的结果是一个列表，其中每个元素都是一个元组，包含了元素和对应的计数值。

需要注意的是，默认情况下，most_common() 方法返回的列表是按照计数值从大到小进行排序的。如果多个元素具有相同的计数值，则它们的顺序可能是不确定的。

通过使用 most_common() 方法，你可以很方便地找到计数对象中出现次数最多的元素，并进一步处理这些元素。

三、【LeetCode实例：383. 赎金信】

LeetCode：383. 赎金信，原题链接：leetcode.cn/problems/ra… 383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：

输入： ransomNote = "a", magazine = "b"
输出： false

示例 2：

输入： ransomNote = "aa", magazine = "ab"
输出： false

示例 3：

输入： ransomNote = "aa", magazine = "aab"
输出： true

提示：

• 1 <= ransomNote.length, magazine.length <= 105
• ransomNote 和 magazine 由小写英文字母组成

因为本人也是一个正在学习的新手小白，所以当时写到这种题目时，本人也是直接暴力解法，循环+判断， 本人一开始的pyhton代码如下：

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        slow,fast=0,0
        l=len(ransomNote)
        ll=len(magazine)
        cun=[]
        while fast<ll:
            if ransomNote[slow]==magazine[fast] and fast not in cun:
                slow=slow+1
                cun.append(fast)
                fast=-1
                if l == len(cun):
                    return True
            fast=fast+1
        return False

理所应当地，这种解法很笨重，创建新数组记录下标，俩指针不断循环判断。

通过学习了collections.Counter()这种方法后，这种题目就十分简单了。以下便是修改后的代码。

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        """
        :type ransomNote: str
        :type magazine: str
        :rtype: bool
        """
        if len(ransomNote)>len(magazine):
            return False
        return not collections.Counter(ransomNote)-collections.Counter(magazine)

本人也是正在学习中，如有错误的地方欢迎大家指正，同时也希望这篇文章能给大家带来帮助！