Python自动化开发从浅入深-语言基础(collection)

Posted 2020-06-13

-- collection是对内置数据类型的一种扩充，其主要扩充类型包括：

　　1.namedtuple(): 生成可以使用名字来访问元素内容的tuple子类，以增强可读性。

def namedtuple(typename, field_names, verbose=False, rename=False):
    """Returns a new subclass of tuple with named fields.
　　   返回一个新的命名域元组子类，typename为类型名，field_names为数据变量域名

    >>> Point = namedtuple(‘Point‘, [‘x‘, ‘y‘]) #定义一个命名元组，类型为Point，数据变量域为[‘x‘,‘y‘]
    >>> Point.__doc__                   # docstring for the new class
    ‘Point(x, y)‘
    >>> p = Point(11, y=22)             # 定义一个Point,x=11,y=22，（instantiate with positional args or keywords）
    >>> p[0] + p[1]                     # 也可以用下标，p[0]即x,p[1]即y，(indexable like a plain tuple)
    33
    >>> x, y = p                        # 也可以这样赋值，p即p[0]和p[1]或p.x和p.y，（unpack like a regular tuple）
    >>> x, y
    (11, 22)
    >>> p.x + p.y                       # fields also accessable by name
    33
    >>> d = p._asdict()                 # convert to a dictionary
    >>> d[‘x‘]
    11
    >>> Point(**d)                      # convert from a dictionary
    Point(x=11, y=22)
    >>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields
    Point(x=100, y=22)

 

　

　　2.deque: 双端队列，可以快速的从另外一侧追加和推出对象。deque其实是 double-ended queue 的缩写，翻译过来就是双端队列，它最大的好处就是实现了从队列 头部快速增加和取出对象: .popleft(), .appendleft() 。

从_collection模块得到：

class deque(object):
    """
    deque([iterable[, maxlen]]) --> deque object
    
    A list-like sequence optimized for data accesses near its endpoints.
    """
    def append(self, *args, **kwargs): # real signature unknown
        """ Add an element to the right side of the deque.从队列右边增加一个元素 
　　　　如：

　　　　　　d = deque()

　　　　　　d.append(‘1‘)

　　　　　　d.append(‘2‘)

　　　　　　d.append(‘3‘)


　　　　　　len(d)

　　　　　　d[0]

　　　　　　d[-1]

　　　　 print(d)
　　　　 print("d[0]=%s,d[1]=%s,d[2]=%s"%(d[0],d[1],d[2]))
　　　　结果
　　　　deque([‘1‘, ‘2‘, ‘3‘])
　　　　d[0]=1,d[1]=2,d[2]=3

　　　　"""

        pass

    def appendleft(self, *args, **kwargs): # real signature unknown
        """ Add an element to the left side of the deque. 从队列左边增加一个元素"""
        pass

    def clear(self, *args, **kwargs): # real signature unknown
        """ Remove all elements from the deque. 清除所有队列数据"""
        pass

    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a deque. 返回一个浅拷贝队列"""
        pass

    def count(self, value): # real signature unknown; restored from __doc__
        """ D.count(value) -> integer -- return number of occurrences of value """
        return 0

    def extend(self, *args, **kwargs): # real signature unknown
        """ Extend the right side of the deque with elements from the iterable 从右边扩充队列值"""
        pass

    def extendleft(self, *args, **kwargs): # real signature unknown
        """ Extend the left side of the deque with elements from the iterable """
        pass

    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """
        D.index(value, [start, [stop]]) -> integer -- return first index of value.返回值得第一个下标
        Raises ValueError if the value is not present.
        """
        return 0

    def insert(self, index, p_object): # real signature unknown; restored from __doc__
        """ D.insert(index, object) -- insert object before index """
        pass

    def pop(self, *args, **kwargs): # real signature unknown
        """ Remove and return the rightmost element. """
        pass

    def popleft(self, *args, **kwargs): # real signature unknown
        """ Remove and return the leftmost element. """
        pass

    def remove(self, value): # real signature unknown; restored from __doc__
        """ D.remove(value) -- remove first occurrence of value. """
        pass

    def reverse(self): # real signature unknown; restored from __doc__
        """ D.reverse() -- reverse *IN PLACE* """
        pass

    def rotate(self, *args, **kwargs): # real signature unknown
        """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """
        pass

 

　　3.Counter: 计数器，主要用来计数,是对字典的一种扩充。

　　下面是Counter类，从dict继承而来。

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‘)  # 从字串中计算元素个数
　　Counter({‘a‘: 5, ‘b‘: 4, ‘c‘: 3, ‘d‘: 2, ‘e‘: 1})
    >>> c.most_common(3)                # 选出3个元素最多的值
    [(‘a‘, 5), (‘b‘, 4), (‘c‘, 3)]
    >>> sorted(c)                       # 对每个独立的元素进行列表排序
    [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]
    >>> ‘‘.join(sorted(c.elements()))   # 按排序列出重复元素
    ‘aaaaabbbbcccdde‘
    >>> sum(c.values())                 # 求出字串元素的总个数
    15

    >>> c[‘a‘]                          # 计算c字串中a元素的个数
    5
     
        #遍历‘shazam‘字串，为每个遍历到的元素数量加1，所以总的a元素数量为7
　　 >>> 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‘]                      # 删除所有的b元素
    >>> c[‘b‘]                          # now there are zero ‘b‘
    0

    >>> d = Counter(‘simsalabim‘)       # 生成一个新的计数器
    >>> c.update(d)                     # 将新的计数器d加到原来的计数器c中
    >>> c[‘a‘]                          # 此时计算的a元素为9个
    9

    >>> c.clear()                       # 清空计数器
    >>> 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                     # 将b元素减少2个
    >>> c.most_common()                 # 此时b仍然存在，但计数数量为0
    [(‘a‘, 3), (‘c‘, 1), (‘b‘, 0)]

    ‘‘‘

 

　　

　　4.OrderedDict: 有序字典　

class OrderedDict(dict):
    ‘Dictionary that remembers insertion order‘
    # An inherited dict maps keys to values.
    # The inherited dict provides __getitem__, __len__, __contains__, and get.
    # The remaining methods are order-aware.
    # Big-O running times for all methods are the same as regular dictionaries.

    # The internal self.__map dict maps keys to links in a doubly linked list.
    # The circular doubly linked list starts and ends with a sentinel element.
    # The sentinel element never gets deleted (this simplifies the algorithm).
    # The sentinel is in self.__hardroot with a weakref proxy in self.__root.
    # The prev links are weakref proxies (to prevent circular references).
    # Individual links are kept alive by the hard reference in self.__map.
    # Those hard references disappear when a key is deleted from an OrderedDict.

def clear(self):
        ‘od.clear() -> None.  Remove all items from od.‘
        root = self.__root
        root.prev = root.next = root
        self.__map.clear()
        dict.clear(self)

    def popitem(self, last=True):
        ‘‘‘od.popitem() -> (k, v), return and remove a (key, value) pair.
        Pairs are returned in LIFO order if last is true or FIFO order if false.

        ‘‘‘
        if not self:
            raise KeyError(‘dictionary is empty‘)
        root = self.__root
        if last:
            link = root.prev
            link_prev = link.prev
            link_prev.next = root
            root.prev = link_prev
        else:
            link = root.next
            link_next = link.next
            root.next = link_next
            link_next.prev = root
        key = link.key
        del self.__map[key]
        value = dict.pop(self, key)
        return key, value

    def move_to_end(self, key, last=True):
        ‘‘‘Move an existing element to the end (or beginning if last==False).

        Raises KeyError if the element does not exist.
        When last=True, acts like a fast version of self[key]=self.pop(key).

        ‘‘‘
        link = self.__map[key]
        link_prev = link.prev
        link_next = link.next
        link_prev.next = link_next
        link_next.prev = link_prev
        root = self.__root
        if last:
            last = root.prev
            link.prev = last
            link.next = root
            last.next = root.prev = link
        else:
            first = root.next
            link.prev = root
            link.next = first
            root.next = first.prev = link

    def __sizeof__(self):
        sizeof = _sys.getsizeof
        n = len(self) + 1                       # number of links including root
        size = sizeof(self.__dict__)            # instance dictionary
        size += sizeof(self.__map) * 2          # internal dict and inherited dict
        size += sizeof(self.__hardroot) * n     # link objects
        size += sizeof(self.__root) * n         # proxy objects
        return size

    update = __update = MutableMapping.update

    def keys(self):
        "D.keys() -> a set-like object providing a view on D‘s keys"
        return _OrderedDictKeysView(self)

    def items(self):
        "D.items() -> a set-like object providing a view on D‘s items"
        return _OrderedDictItemsView(self)

    def values(self):
        "D.values() -> an object providing a view on D‘s values"
        return _OrderedDictValuesView(self)

    __ne__ = MutableMapping.__ne__

    __marker = object()

    def pop(self, key, default=__marker):
        ‘‘‘od.pop(k[,d]) -> v, remove specified key and return the corresponding
        value.  If key is not found, d is returned if given, otherwise KeyError
        is raised.

        ‘‘‘
        if key in self:
            result = self[key]
            del self[key]
            return result
        if default is self.__marker:
            raise KeyError(key)
        return default

    def setdefault(self, key, default=None):
        ‘od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od‘
        if key in self:
            return self[key]
        self[key] = default
        return default

    @_recursive_repr()
    def __repr__(self):
        ‘od.__repr__() <==> repr(od)‘
        if not self:
            return ‘%s()‘ % (self.__class__.__name__,)
        return ‘%s(%r)‘ % (self.__class__.__name__, list(self.items()))

    def __reduce__(self):
        ‘Return state information for pickling‘
        inst_dict = vars(self).copy()
        for k in vars(OrderedDict()):
            inst_dict.pop(k, None)
        return self.__class__, (), inst_dict or None, None, iter(self.items())

    def copy(self):
        ‘od.copy() -> a shallow copy of od‘
        return self.__class__(self)

    @classmethod
    def fromkeys(cls, iterable, value=None):
        ‘‘‘OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
        If not specified, the value defaults to None.

        ‘‘‘
        self = cls()
        for key in iterable:
            self[key] = value
        return self

    def __eq__(self, other):
        ‘‘‘od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
        while comparison to a regular mapping is order-insensitive.

        ‘‘‘
        if isinstance(other, OrderedDict):
            return dict.__eq__(self, other) and all(map(_eq, self, other))
        return dict.__eq__(self, other)


try:
    from _collections import OrderedDict
except ImportError:
    # Leave the pure Python version in place.
    pass

 

　　　

　　5.defaultdict: 带有默认值的字典

 　　　　我们都知道，在使用Python原生的数据结构dict的时候，如果用 d[key] 这样的方式访问， 当指定的key不存在时，是会抛出KeyError异常的。

　　　　但是，如果使用defaultdict，只要你传入一个默认的工厂方法，那么请求一个不存在的key时， 便会调用这个工厂方法使用其结果来作为这个key的默认值。

class defaultdict(dict):
    """
    defaultdict(default_factory[, ...]) --> dict with default factory
    
    The default factory is called without arguments to produce
    a new value when a key is not present, in __getitem__ only.
    A defaultdict compares equal to a dict with the same items.
    All remaining arguments are treated the same as if they were
    passed to the dict constructor, including keyword arguments.
    """
    def copy(self): # real signature unknown; restored from __doc__
        """ D.copy() -> a shallow copy of D. """
        pass

    def __copy__(self, *args, **kwargs): # real signature unknown
        """ D.copy() -> a shallow copy of D. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, default_factory=None, **kwargs): # known case of _collections.defaultdict.__init__
        """
        defaultdict(default_factory[, ...]) --> dict with default factory
        
        The default factory is called without arguments to produce
        a new value when a key is not present, in __getitem__ only.
        A defaultdict compares equal to a dict with the same items.
        All remaining arguments are treated the same as if they were
        passed to the dict constructor, including keyword arguments.
        
        # (copied from class doc)
        """
        pass

    def __missing__(self, key): # real signature unknown; restored from __doc__
        """
        __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
          if self.default_factory is None: raise KeyError((key,))
          self[key] = value = self.default_factory()
          return value
        """
        pass

    def __reduce__(self, *args, **kwargs): # real signature unknown
        """ Return state information for pickling. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    default_factory = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Factory for default value called by __missing__()."""