Python 计数器:如何使用 collections.Counter?

王林
发布: 2023-05-08 13:34:07
转载
1060 人浏览过

    一. 介绍

    一个计数器工具提供快速和方便的计数,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 &#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 用自带的items()方法输出

    显然这个方法比转换为字典后再输出的方法更为方便:

    print(temp.items()) #dict_items([(&#39;e&#39;, 1), (&#39;c&#39;, 3), (&#39;b&#39;, 4), (&#39;d&#39;, 2), (&#39;a&#39;, 5)])
     
    for item in temp.items():
        print(item)
    """
    (&#39;a&#39;, 5)
    (&#39;c&#39;, 3)
    (&#39;d&#39;, 2)
    (&#39;e&#39;, 1)
    (&#39;b&#39;, 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(&#39;abracadabra&#39;).most_common(3)
    [(&#39;a&#39;, 5), (&#39;b&#39;, 2), (&#39;r&#39;, 2)]
    
    Counter(&#39;abracadabra&#39;).most_common(5)
    [(&#39;a&#39;, 5), (&#39;b&#39;, 2), (&#39;r&#39;, 2), (&#39;c&#39;, 1), (&#39;d&#39;, 1)]
    登录后复制

    3. elements() 和 sort()方法

    描述:返回一个迭代器,其中每个元素将重复出现计数值所指定次。 元素会按首次出现的顺序返回。 如果一个元素的计数值小于1,elements() 将会忽略它。
    举例:

    c = Counter(a=4, b=2, c=0, d=-2)
    list(c.elements())
    [&#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;b&#39;, &#39;b&#39;]
    
    sorted(c.elements())
    [&#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;b&#39;, &#39;b&#39;]
    
    c = Counter(a=4, b=2, c=0, d=5)
    list(c.elements())
    [&#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;b&#39;, &#39;b&#39;, &#39;d&#39;, &#39;d&#39;, &#39;d&#39;, &#39;d&#39;, &#39;d&#39;]
    登录后复制
    from collections import Counter
     
    c = Counter(&#39;ABCABCCC&#39;)
    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;]
    登录后复制

    官方文档例子:

    # Knuth&#39;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({&#39;a&#39;: 3, &#39;b&#39;: 0, &#39;c&#39;: -3, &#39;d&#39;: -6})
    
    #减去一个abcd
    str0 = Counter(&#39;aabbccdde&#39;)
    str0
    Counter({&#39;a&#39;: 2, &#39;b&#39;: 2, &#39;c&#39;: 2, &#39;d&#39;: 2, &#39;e&#39;: 1})
    
    str0.subtract(&#39;abcd&#39;)
    str0
    Counter({&#39;a&#39;: 1, &#39;b&#39;: 1, &#39;c&#39;: 1, &#39;d&#39;: 1, &#39;e&#39;: 1}
    登录后复制
    subtract_test01 = Counter("AAB")
    subtract_test01.subtract("BCC")
    print(subtract_test01)  #Counter({&#39;A&#39;: 2, &#39;B&#39;: 0, &#39;C&#39;: -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({&#39;a&#39;: 4, &#39;b&#39;: 3})
    c - d                       # subtract (keeping only positive counts)
    Counter({&#39;a&#39;: 2})
    c & d                       # intersection:  min(c[x], d[x]) 
    Counter({&#39;a&#39;: 1, &#39;b&#39;: 1})
    c | d                       # union:  max(c[x], d[x])
    Counter({&#39;a&#39;: 3, &#39;b&#39;: 2})
    登录后复制
    print(Counter(&#39;AAB&#39;) + Counter(&#39;BCC&#39;))
    #Counter({&#39;B&#39;: 2, &#39;C&#39;: 2, &#39;A&#39;: 2})
    print(Counter("AAB")-Counter("BCC"))
    #Counter({&#39;A&#39;: 2})
    登录后复制

    与”和“或”操作:

    print(Counter(&#39;AAB&#39;) & Counter(&#39;BBCC&#39;))
    #Counter({&#39;B&#39;: 1})
     
    print(Counter(&#39;AAB&#39;) | Counter(&#39;BBCC&#39;))
    #Counter({&#39;A&#39;: 2, &#39;C&#39;: 2, &#39;B&#39;: 2})
    登录后复制

    单目加和减(一元操作符)意思是从空计数器加或者减去,相当于给计数值乘以正值或负值,同样输出会忽略掉结果为零或者小于零的计数:

    c = Counter(a=2, b=-4)
    +c
    Counter({&#39;a&#39;: 2})
    -c
    Counter({&#39;b&#39;: 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 = &#39;定位手机定位汽车定位GPS定位人定位位置查询&#39;         
    str_1 = &#39;导航定位手机定位汽车定位GPS定位人定位位置查询&#39;         
    
    str_sim(str_0,str_1,5)    
    0.75
    登录后复制

    7. 计算元素总数、Keys() 和 Values()

    from collections import Counter
     
    c = Counter(&#39;ABCABCCC&#39;)
    print(sum(c.values()))  # 8  total of all counts
     
    print(c.keys())  #dict_keys([&#39;A&#39;, &#39;B&#39;, &#39;C&#39;])
    print(c.values())  #dict_values([2, 2, 4])
    登录后复制

    8. 查询单元素结果

    from collections import Counter
    c = Counter(&#39;ABBCC&#39;)
    #查询具体某个元素的个数
    print(c["A"])  #1
    登录后复制

    9. 添加

    for elem in &#39;ADD&#39;:  # update counts from an iterabl
        c[elem] += 1
    print(c.most_common())  #[(&#39;C&#39;, 2), (&#39;D&#39;, 2), (&#39;A&#39;, 2), (&#39;B&#39;, 2)]
    #可以看出“A”增加了一个,新增了两个“D”
    登录后复制

    10. 删除(del)

    del c["D"]
    print(c.most_common())  #[(&#39;C&#39;, 2), (&#39;A&#39;, 2), (&#39;B&#39;, 2)]
    del c["C"]
    print(c.most_common())  #[(&#39;A&#39;, 2), (&#39;B&#39;, 2)]
    登录后复制

    11. 更新 update()

    d = Counter("CCDD")
    c.update(d)
    print(c.most_common())  #[(&#39;B&#39;, 2), (&#39;A&#39;, 2), (&#39;C&#39;, 2), (&#39;D&#39;, 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(&#39;hello world&#39;)
    Counter({&#39;l&#39;: 3, &#39;o&#39;: 2, &#39;h&#39;: 1, &#39;e&#39;: 1, &#39; &#39;: 1, &#39;w&#39;: 1, &#39;r&#39;: 1, &#39;d&#39;: 1})
    # 统计单词数
    >>> collections.Counter(&#39;hello world hello world hello nihao&#39;.split())
    Counter({&#39;hello&#39;: 3, &#39;world&#39;: 2, &#39;nihao&#39;: 1})
    登录后复制

    常用的方法:

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

    以上是Python 计数器:如何使用 collections.Counter?的详细内容。更多信息请关注PHP中文网其他相关文章!

    相关标签:
    来源:yisu.com
    本站声明
    本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn
    热门教程
    更多>
    最新下载
    更多>
    网站特效
    网站源码
    网站素材
    前端模板
    关于我们 免责声明 Sitemap
    PHP中文网:公益在线PHP培训,帮助PHP学习者快速成长!