深入了解Python collection模块与深浅拷贝

collection模块是对Python的通用内置容器：字典、列表、元组和集合的扩展，它包含一些专业的容器数据类型：

Counter（计数器）：dict子类，用于计算可哈希性对象的个数。

OrderedDict（有序字典）：dict 子类，记录着数据成员添加的顺序。

defaultdict(默认字典）：dict 子类，调用一个工厂函数来为dict的values值缺失提供一个默认值。

namedtuple(可命名元组）：工厂函数生成有命名字段的tuple子类。

deque(双向队列）：能在“队列”两端快速出队、入队的函数，类似于队列的（list-like）的容器。

ChainMap:为多个映射创建单一视图的类字典类型。

UserDict：将字典包裹起来使得创建字典的子类更容易。

UserList：将列表对象包裹起来使得创建列表的子类更容易。

UserString：将字符串对象包裹起来使得创建字符串的子类更容易。

1.计数器（counter）

Counter是dict的子类，用于计数可哈希性对象。它是一个无序的容器，元素存储为字典键，计数值存储为字典值。计数允许任何整数值，包括零或负计数。Counter类相似于bags或multisets等语言类。

它的元素从一个可迭代对象计数，或从另一个映射（或计数器）初始化。

class Counter(dict):    '''Dict subclass for counting hashable items.  Sometimes called a bag    or multiset.  Elements are stored as dictionary keys and their counts    are stored as dictionary values.    >>> c = Counter('abcdeabcdabcaba')  # count elements from a string    >>> c.most_common(3)                # three most common elements    [('a', 5), ('b', 4), ('c', 3)]    >>> sorted(c)                       # list all unique elements    ['a', 'b', 'c', 'd', 'e']    >>> ''.join(sorted(c.elements()))   # list elements with repetitions    'aaaaabbbbcccdde'    >>> sum(c.values())                 # total of all counts    15    >>> c['a']                          # count of letter 'a'    5    >>> for elem in 'shazam':           # update counts from an iterable    ...     c[elem] += 1                # by adding 1 to each element's count    >>> c['a']                          # now there are seven 'a'    7    >>> del c['b']                      # remove all 'b'    >>> c['b']                          # now there are zero 'b'    0    >>> d = Counter('simsalabim')       # make another counter    >>> c.update(d)                     # add in the second counter    >>> c['a']                          # now there are nine 'a'    9    >>> c.clear()                       # empty the counter    >>> c    Counter()    Note:  If a count is set to zero or reduced to zero, it will remain    in the counter until the entry is deleted or the counter is cleared:    >>> c = Counter('aaabbc')    >>> c['b'] -= 2                     # reduce the count of 'b' by two    >>> c.most_common()                 # 'b' is still in, but its count is zero    [('a', 3), ('c', 1), ('b', 0)]    '''    # References:    #   http://en.wikipedia.org/wiki/Multiset    #   http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html    #   http://www.demo2s.com/Tutorial/Cpp/0380set-multiset/Catalog0380set-multiset.htm    #   http://code.activestate.com/recipes/259174/    #   Knuth, TAOCP Vol. II section 4.6.3    def init(*args, **kwds):        '''Create a new, empty Counter object.  And if given, count elements        from an input iterable.  Or, initialize the count from another mapping        of elements to their counts.        >>> c = Counter()                           # a new, empty counter        >>> c = Counter('gallahad')                 # a new counter from an iterable        >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping        >>> c = Counter(a=4, b=2)                   # a new counter from keyword args        '''        if not args:            raise TypeError("descriptor 'init' of 'Counter' object "                            "needs an argument")        self, *args = args        if len(args) > 1:            raise TypeError('expected at most 1 arguments, got %d' % len(args))        super(Counter, self).init()        self.update(*args, **kwds)    def missing(self, key):        'The count of elements not in the Counter is zero.'        # Needed so that self[missing_item] does not raise KeyError        return 0    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('abcdeabcdabcaba').most_common(3)        [('a', 5), ('b', 4), ('c', 3)]        '''        # 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))    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()))    # Override dict methods where necessary    @classmethod    def fromkeys(cls, iterable, v=None):        # There is no equivalent method for counters because setting v=1        # means that no element can have a count greater than one.        raise NotImplementedError(            'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')    def update(*args, **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 not args:            raise TypeError("descriptor 'update' of 'Counter' object "                            "needs an argument")        self, *args = args        if len(args) > 1:            raise TypeError('expected at most 1 arguments, got %d' % len(args))        iterable = args[0] if args else None        if iterable is not None:            if isinstance(iterable, 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)    def subtract(*args, **kwds):        '''Like dict.update() but subtracts counts instead of replacing them.        Counts can be reduced below zero.  Both the inputs and outputs are        allowed to contain zero and negative counts.        Source can be an iterable, a dictionary, or another Counter instance.        >>> c = Counter('which')        >>> c.subtract('witch')             # subtract elements from another iterable        >>> c.subtract(Counter('watch'))    # subtract elements from another counter        >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch        0        >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch        -1        '''        if not args:            raise TypeError("descriptor 'subtract' of 'Counter' object "                            "needs an argument")        self, *args = args        if len(args) > 1:            raise TypeError('expected at most 1 arguments, got %d' % len(args))        iterable = args[0] if args else None        if iterable is not None:            self_get = self.get            if isinstance(iterable, Mapping):                for elem, count in iterable.items():                    self[elem] = self_get(elem, 0) - count            else:                for elem in iterable:                    self[elem] = self_get(elem, 0) - 1        if kwds:            self.subtract(kwds)    def copy(self):        'Return a shallow copy.'        return self.class(self)    def reduce(self):        return self.class, (dict(self),)    def delitem(self, elem):        'Like dict.delitem() but does not raise KeyError for missing values.'        if elem in self:            super().delitem(elem)    def repr(self):        if not self:            return '%s()' % self.class.name        try:            items = ', '.join(map('%r: %r'.mod, self.most_common()))            return '%s({%s})' % (self.class.name, items)        except TypeError:            # handle case where values are not orderable            return '{0}({1!r})'.format(self.class.name, dict(self))    # Multiset-style mathematical operations discussed in:    #       Knuth TAOCP Volume II section 4.6.3 exercise 19    #       and at http://en.wikipedia.org/wiki/Multiset    #    # Outputs guaranteed to only include positive counts.    #    # To strip negative and zero counts, add-in an empty counter:    #       c += Counter()    def add(self, other):        '''Add counts from two counters.        >>> Counter('abbb') + Counter('bcc')        Counter({'b': 4, 'c': 2, 'a': 1})        '''        if not isinstance(other, Counter):            return NotImplemented        result = Counter()        for elem, count in self.items():            newcount = count + other[elem]            if newcount > 0:                result[elem] = newcount        for elem, count in other.items():            if elem not in self and count > 0:                result[elem] = count        return result    def sub(self, other):        ''' Subtract count, but keep only results with positive counts.        >>> Counter('abbbc') - Counter('bccd')        Counter({'b': 2, 'a': 1})        '''        if not isinstance(other, Counter):            return NotImplemented        result = Counter()        for elem, count in self.items():            newcount = count - other[elem]            if newcount > 0:                result[elem] = newcount        for elem, count in other.items():            if elem not in self and count < 0:                result[elem] = 0 - count        return result    def or(self, other):        '''Union is the maximum of value in either of the input counters.        >>> Counter('abbb') | Counter('bcc')        Counter({'b': 3, 'c': 2, 'a': 1})        '''        if not isinstance(other, Counter):            return NotImplemented        result = Counter()        for elem, count in self.items():            other_count = other[elem]            newcount = other_count if count < other_count else count            if newcount > 0:                result[elem] = newcount        for elem, count in other.items():            if elem not in self and count > 0:                result[elem] = count        return result    def and(self, other):        ''' Intersection is the minimum of corresponding counts.        >>> Counter('abbb') & Counter('bcc')        Counter({'b': 1})        '''        if not isinstance(other, Counter):            return NotImplemented        result = Counter()        for elem, count in self.items():            other_count = other[elem]            newcount = count if count < other_count else other_count            if newcount > 0:                result[elem] = newcount        return result    def pos(self):        'Adds an empty counter, effectively stripping negative and zero counts'    <strong style="color:transparent">本文来源gao@daima#com搞(%代@#码@网&</strong>    result = Counter()        for elem, count in self.items():            if count > 0:                result[elem] = count        return result    def neg(self):        '''Subtracts from an empty counter.  Strips positive and zero counts,        and flips the sign on negative counts.        '''        result = Counter()        for elem, count in self.items():            if count < 0:                result[elem] = 0 - count        return result    def _keep_positive(self):        '''Internal method to strip elements with a negative or zero count'''        nonpositive = [elem for elem, count in self.items() if not count > 0]        for elem in nonpositive:            del self[elem]        return self    def iadd(self, other):        '''Inplace add from another counter, keeping only positive counts.        >>> c = Counter('abbb')        >>> c += Counter('bcc')        >>> c        Counter({'b': 4, 'c': 2, 'a': 1})        '''        for elem, count in other.items():            self[elem] += count        return self._keep_positive()    def isub(self, other):        '''Inplace subtract counter, but keep only results with positive counts.        >>> c = Counter('abbbc')        >>> c -= Counter('bccd')        >>> c        Counter({'b': 2, 'a': 1})        '''        for elem, count in other.items():            self[elem] -= count        return self._keep_positive()    def ior(self, other):        '''Inplace union is the maximum of value from either counter.        >>> c = Counter('abbb')        >>> c |= Counter('bcc')        >>> c        Counter({'b': 3, 'c': 2, 'a': 1})        '''        for elem, other_count in other.items():            count = self[elem]            if other_count > count:                self[elem] = other_count        return self._keep_positive()    def iand(self, other):        '''Inplace intersection is the minimum of corresponding counts.        >>> c = Counter('abbb')        >>> c &= Counter('bcc')        >>> c        Counter({'b': 1})        '''        for elem, count in self.items():            other_count = other[elem]            if other_count < count:                self[elem] = other_count        return self._keep_positive()Counter

喜欢 (0)赏

[搞代码]

分享 (0)