Python collections模块-Counter

概要

  1. Counter支持三种初始化方式
  2. Counter是Python内部用来对元素进行计数的一个模块
  3. Counter继承了字典
  4. Counter包含了elements, most_common, subtract, update这些方法, 可以在数据统计方面帮助到我们
  5. Counter支持使用加减, 且或这四种运算符

Counter支持使用序列, 字典, 或者命名参数的形式进行初始化

  • 使用序列(列表, 字符串, 元祖这类序列)初始化
from collections import Counter

counter = Counter([1,2,3,1,2,3])
print(counter)
# Counter([1: 2, 2: 2, 3: 3])

counter = Counter(((1,2), (3,4)))
print(counter)
# Counter({(1, 2): 1, (3, 4): 1})
# 使用序列进行初始化时, Counter会对序列中的元素进行计数, 包括二维序列.

# 而字典对于二维序列是不同的
print(dict(((1,2), (3,4))))
# {1: 2, 3: 4}
  • 使用字典初始化
from collections import Counter

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

# Counter({'c': 3, 'b': 2, 'a': 1})
# 可以看到,Counter直接初始化的字典直接当做元素->计数对待的。
  • 使用命名参数初始化
from collections import Counter

counter = Counter(a=1, b=2, c=3)
print(counter)
# Counter({'c': 3, 'b': 2, 'a': 1})
# 这种初始化方式与使用字典也比较类似

Counter继承了dict类型, 支持dict的大部分方法, 但是通过某些魔法方法, 定制了一些特殊行为

  • Counter重写了__missing__方法, 当你在Counter中索引一个不存在的元素时, 它会返回0. 而不像dict一样抛出KeyError异常
counter = Counter('abc')
print(counter)
# Counter({'a': 1, 'b': 1, 'c': 1})

d = dict(counter)
print(d)
# {'a': 1, 'b': 1, 'c': 1}

assert counter['d'] == 0
# 正常
assert d['d'] == 0
# KeyError
  • __missing__方法不仅在索引元素时生效, 在删除元素时同样有效
del counter['d']
# 正常
del d['d'] 
# KeyError
  • key存在时, Counter和dict的删除行为是一样的
del counter['a']
print(counter)
# Counter({'b': 1, 'c': 1})
del d['a']
# {'b': 1, 'c': 1}

Counter从dict集成的一些方法和行为

  • Counter.values: 返回所有的值(value)
counter = Counter('abcdef')
print(counter.values())
# dict_values([1, 1, 1, 1, 1, 1])
  • Counter.items: 返回所有的键值对(key->value pair)
print(counter.items())
# dict_items([('a', 1), ('b', 1), ('c', 1), ('d', 1), ('e', 1), ('f', 1)])
  • list(counter): 会将所有的key返回
print(list(counter))
# ['a', 'b', 'c', 'd', 'e', 'f']
  • Counter.clear: 清空counter
counter.clear()
print(counter)
# Counter() 清空所有的元素

Counter的一些特有的方法

  • Counter.elements: 是通过序列初始化Counter的反过程, 即通过元素和计数生成元素序列, 计数就是元素在序列中的出现次数
counter = Counter({'a': 1, 'b': 2, 'c': 3, 'd': 0, 'e': -1})
print(list(counter))
# ['a', 'b', 'b', 'c', 'c', 'c'],
# counter将按照计数,将元素进行输出,
# 在这里输出了1个a,2个b,3个c
# 如果元素对应计数是0,或者负数则不会输出。
  • Counter.most_common: 按照元素计数的降序返回指定数量的元素, 当没有指定数量时, 按照降序返回所有的元素
print(counter.most_common())
# [('c', 3), ('b', 2), ('a', 1), ('d', 0), ('e', -1)] 
# most_common将按照计数的降序返回一个列表

print(counter.most_common(2))
# most_common也可以接受一个参数
# [('c', 3), ('b', 2)],返回降序中前n个元素
  • Counter.subtract: 对自身的计数进行操作, 如果同时存在于自身和传入的参数, 就会将对应元素的计数更新为: 目前的计数 - 传入参数中元素的计数
counter1 = Counter('abcdabcd') # abcd abcd
counter2 = Counter('abc')
counter1.subtract(counter2)
print(counter1)
# Counter({'d': 2, 'a': 1, 'b': 1, 'c': 1})

# 入参也可以是序列
counter1 = Counter('abcdabcd') # abcd abcd
counter1.subtract('abc')
print(counter1)
# Counter({'d': 2, 'a': 1, 'b': 1, 'c': 1})

# 也可以是字典
counter1 = Counter('abcdabcd') # abcd abcd
counter2 = Counter('abc')
counter1.subtract(dict(counter2))
print(counter1)
# Counter({'d': 2, 'a': 1, 'b': 1, 'c': 1})
  • Counter.update: 与subtract的行为相反, 会将对应的计数更新为: 目前的计数 + 传入参数中元素的技术
counter1 = Counter('abcdabcd') # abcd abcd
counter2 = Counter('abc')
counter1.update(counter2)
print(counter1)
# Counter({'a': 3, 'b': 3, 'c': 3, 'd': 2})

Counter的一些算术运算符

  • + : 与 Counter.update 的操作相同, 但是不是基于自身更新, 而是返回一个新的Counter
counter1 = Counter('abcdabcd') # abcd abcd
counter2 = Counter('abc')
print(counter1 + counter2)
# Counter({'a': 3, 'b': 3, 'c': 3, 'd': 2})
  • - :与Counter.subtract操作相同,但是不是基于自身更新, 而是返回一个新的Counter
counter1 = Counter('abcdabcd') # abcd abcd
counter2 = Counter('abc')
print(counter1 - counter2)
# Counter({'d': 2, 'a': 1, 'b': 1, 'c': 1})
  • &: 返回的Counter是这样得来的, 1: 结果中的元素是对参与运算的两者的元素取交集的结果. 2: 元素的计数为两者中较小值
counter1 = Counter('abcdabcd') # abcd abcd
counter2 = Counter('abc')
print(counter1 & counter2)
# Counter({'a': 1, 'b': 1, 'c': 1})
# 交集 两者中的较小值
  • | : 与&操作相反, 1: 结果中的元素是对参与运算的两者的元素取并集的结果. 2: 元素的计数为两者中的较大值
counter1 = Counter('abcdabcd') # abcd abcd
counter2 = Counter('abc')
print(counter1 | counter2)
# Counter({'a': 2, 'b': 2, 'c': 2, 'd': 2})
# 并集 两者中的较大值
展示评论