当前位置： 移动技术网 > IT编程>脚本编程>Python > 荐 python学习——collections模块之Counter

荐 python学习——collections模块之Counter

2020年07月14日  | 移动技术网IT编程  | 我要评论

一、Counter是用来统计个数的

  • 下面是用传统方法统计个数，随机生成长度为20的字符串，用defaultdict初始化字典

在这里插入图片描述

  • 用Counter来统计
    在这里插入图片描述
  • 在实例化的之后直接将待统计的可迭代对象传进去即可，注意是可迭代对象，下图是源码的一些使用方法
    在这里插入图片描述
  • __init__
    在这里插入图片描述
  • Counter有6个方法，下面咱们就讲讲这些方法的用法
    在这里插入图片描述

  1. most_commom

    def most_common(self, n=None):
    '''List the n most common elements and their counts from the most
    common to the least.  If n is None, then list all element counts.

    >>> Counter('abracadabra').most_common(3)
    [('a', 5), ('b', 2), ('r', 2)]

    '''
    # Emulate Bag.sortedByCount from Smalltalk
    if n is None:
        return sorted(self.items(), key=_itemgetter(1), reverse=True)
    return _heapq.nlargest(n, self.items(), key=_itemgetter(1))
  • 可以看到，Counter(iterable).most_common返回的是一个列表，列表里面是元组，元组的第一个元素是统计的值，元组的第二个元素是该值的个数，如果传入n，那么结果就是前n个元素的统计结果
    在这里插入图片描述

  1. elements，返回的是itertools.chain对象，可以使用list转换类型。

    def elements(self):
    '''Iterator over elements repeating each as many times as its count.

    >>> c = Counter('ABCABC')
    >>> sorted(c.elements())
    ['A', 'A', 'B', 'B', 'C', '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
    >>> product
    1836

    Note, if an element's count has been set to zero or is a negative
    number, elements() will ignore it.

    '''
    # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
    return _chain.from_iterable(_starmap(_repeat, self.items()))
  1. subtract两个统计结果相减，会改变原来的数值，下图是c的结果减去a的结果
    在这里插入图片描述
  • 该方法传入的参数是可迭代对象，不一定是Counter实例化对象，如果c中没有该值，则该值置为0，然后个数相减
    在这里插入图片描述

  1. copy浅拷贝，不多赘述

    def copy(self):
    'Return a shallow copy.'
    return self.__class__(self)

  2. fromkeys

    @classmethod
def fromkeys(cls, iterable, v=None):
    # There is no equivalent method for counters because the semantics
    # would be ambiguous in cases such as Counter.fromkeys('aaabbc', v=2).
    # Initializing counters to zero values isn't necessary because zero
    # is already the default value for counter lookups.  Initializing
    # to one is easily accomplished with Counter(set(iterable)).  For
    # more exotic cases, create a dictionary first using a dictionary
    # comprehension or dict.fromkeys().
    raise NotImplementedError(
        'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')
  • 该方法是抛出NotImplementedError异常的，咱们知道dict也有fromkeys方法，Counter是继承dict的，作者认为用Counter去初始化一个Counter对象是没必要的，因为初始化的时候可以直接Counter(itrable)就行了，没有必要再去使用fromkeys去初始化，所以这里选择覆盖了dict的fromkeys方法，让其抛出异常
    在这里插入图片描述

  1. update该方法重写了dict的update方法，如果该值存在，就累加，如果不存在就新添加进去，接受一个可迭代对象，也可以是关键字参数，或者字典

    def update(self, iterable=None, /, **kwds):
    '''Like dict.update() but add counts instead of replacing them.

    Source can be an iterable, a dictionary, or another Counter instance.

    >>> c = Counter('which')
    >>> c.update('witch')           # add elements from another iterable
    >>> d = Counter('watch')
    >>> c.update(d)                 # add elements from another counter
    >>> c['h']                      # four 'h' in which, witch, and watch
    4

    '''
    # The regular dict.update() operation makes no sense here because the
    # replace behavior results in the some of original untouched counts
    # being mixed-in with all of the other counts for a mismash that
    # doesn't have a straight-forward interpretation in most counting
    # contexts.  Instead, we implement straight-addition.  Both the inputs
    # and outputs are allowed to contain zero and negative counts.

    if iterable is not None:
        if isinstance(iterable, _collections_abc.Mapping):
            if self:
                self_get = self.get
                for elem, count in iterable.items():
                    self[elem] = count + self_get(elem, 0)
            else:
                super(Counter, self).update(iterable) # fast path when counter is empty
        else:
            _count_elements(self, iterable)
    if kwds:
        self.update(kwds)

    在这里插入图片描述
    在这里插入图片描述

二、全局完！！

本文地址：https://blog.csdn.net/weixin_44024393/article/details/107315887

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网