Python标准库—collections模块

Collections

这个模块实现专门的容器数据类型提供替代Python的通用内置容器dict，list， set，和tuple。

• namedtuple()

  用于创建具有命名字段的元组子类工厂函数。

• deque

  类似列表的容器，可在两端进行快速的添加和删除。

• Counter

  用于对可hash对象计数的dict子类

• OrderedDict

• defaultDict

• UserDict对象

• UserList对象

• UserString对象

namedtuple()

collections.namedtuple（typename，field_names ,verbose = False , rename = False）

返回名为typename的新元组子类。

field_names是一个字符串序列如[‘x’,‘y’]，或者为单个字符串，每个字段名由空格’ ‘或逗号分隔’,’。

verbose=True，则在构建之前打印类定义。

rename=True，则无效的字段名称将自动替换为位置名称。

>>> from collections import namedtuple
>>> StuInfo  = namedtuple('Student',"name grade age",verbose=True)
from builtins import property as _property, tuple as _tuple
from operator import itemgetter as _itemgetter
from collections import OrderedDict

class Student(tuple):
    'Student(name, grade, age)'

    __slots__ = ()

    _fields = ('name', 'grade', 'age')

    def __new__(_cls, name, grade, age):
        'Create new instance of Student(name, grade, age)'
        return _tuple.__new__(_cls, (name, grade, age))

    @classmethod
    def _make(cls, iterable, new=tuple.__new__, len=len):
        'Make a new Student object from a sequence or iterable'
        result = new(cls, iterable)
        if len(result) != 3:
            raise TypeError('Expected 3 arguments, got %d' % len(result))
        return result

    def _replace(_self, **kwds):
        'Return a new Student object replacing specified fields with new values'
        result = _self._make(map(kwds.pop, ('name', 'grade', 'age'), _self))
        if kwds:
            raise ValueError('Got unexpected field names: %r' % list(kwds))
        return result

    def __repr__(self):
        'Return a nicely formatted representation string'
        return self.__class__.__name__ + '(name=%r, grade=%r, age=%r)' % self

    def _asdict(self):
        'Return a new OrderedDict which maps field names to their values.'
        return OrderedDict(zip(self._fields, self))

    def __getnewargs__(self):
        'Return self as a plain tuple.  Used by copy and pickle.'
        return tuple(self)

    name = _property(_itemgetter(0), doc='Alias for field number 0')

    grade = _property(_itemgetter(1), doc='Alias for field number 1')

    age = _property(_itemgetter(2), doc='Alias for field number 2')



>>> s = StuInfo(name='zwj',grade=3,age=22)
>>> s
Student(name='zwj', grade=3, age=22)
>>> s.name
'zwj'
>>> s[2]
22
>>> 

Counter对象

提供计数器工具以支持方便和快速的计数。

class collections.Counter（[ iterable-or-mapping ] ）

Counter是dict用于计算可哈希对象的子类。它是一个无序集合，其中元素存储为字典键，其计数存储为字典值。计数允许为任何整数值，包括零或负计数。

• 除了为缺失键返回0之外(dict返回KeyError)，Counter和dict有着相同的接口。
• Counter对象将键的值置为0不会删除元素，删除一个元素可用del。

>>> c = Counter({'a':1,'b':2})				#映射对象初始化Counter对象
>>> c = Counter('aaaaabbbccd')              #可迭代对象初始化Counter对象
>>> c                                        
Counter({'a': 5, 'b': 3, 'c': 2, 'd': 1})                        
>>> c1['a']                                  
5                                           #缺失键不抛出KeyError而返回0 
>>> c1['f']                                   
0                                             
>>> c1['a']=0                               #将值置为0并不会从Counter对象中删除元素  
>>> c1                                        
Counter({'b': 3, 'c': 2, 'd': 1, 'a': 0})     
>>> del c1['a']                               
>>> c1                                        
Counter({'b': 3, 'c': 2, 'd': 1})             
>>>                                           

Counter对象除了支持所以dict所有方法外，还支持这3个方法。

• elements()

  返回一个包含元素的迭代器，重复每个元素出现的次数。如果元素计数小于1，则忽略。

• most_common( [n] )

  从计数大到小，返回n个最常见元素及其计数的列表。如果n未指定或为None，则返回Counter对象中的所有元素。

• subtract( [ iterable-or-mapping ] )

  从可迭代对象或另一个*映射（或Counter对象）*中减去元素。

>>> c = Counter({'a':3,'b':2,'c':1,'d':-2})
>>> list(c.elements())
['c', 'b', 'b', 'a', 'a', 'a']
>>> c.most_common(2)
[('a', 3), ('b', 2)]
>>> c.subtract('abcd')				#减去abcd
>>> c
Counter({'a': 2, 'b': 1, 'c': 0, 'd': -3})

deque对象（双端队列）

类似列表的容器，可在两端进行快速的添加和删除。(列表在删除第一个元素时非常耗时，因为涉及到移动列表所有元素)

class collections.deque（[ iterable [，maxlen ] ] ）

• 返回一个从左到右（使用append()）初始化的新deque对象，其中包含来自iterable的数据。如果未指定iterable，则新的deque为空。
• 参数maxlen为双端队列的最大长度，未指定或为None代表无边界。

deque对象提供的方法：

• deque对象提供的方法与list提供的方法类似，只是扩展了左右两端的方法。如append()、appendleft()；pop()、popleft()。

• rotate（n = 1 ）

  将deque对象向右旋转 n步。如果n为负数，则向左旋转。

deque对象还提供一个只读属性：

• maxlen

  双端队列对象的最大长度或None代表无边界。

>>> from collections import deque
>>> d = deque([4,5,6])		#列表初始化双端队列，maxlen默认为None
>>> d
deque([4, 5, 6])
>>> d.extend([1,2,3])		#扩展
>>> d
deque([4, 5, 6, 1, 2, 3])
>>> d.rotate(3)				#将左边3个元素移至右边
>>> d
deque([1, 2, 3, 4, 5, 6])
>>> d.popleft()				#弹出d中左边的元素
1
>>> d
deque([2, 3, 4, 5, 6])
>>> print(d.maxlen)
None

利用deque得到文件最后n行(类似UNIX中的tail过滤器)

def tail(filename, n=10):
    'Return the last n lines of a file'
    with open(filename) as f:
        return deque(f, n)

UserDict对象

此类其实就是把标准dict用纯Python又实现了一遍。

如果需要创造自定义映射类型，以UserDict为基准，总比以内置的dict为基准要方便。更倾向于从UserDict而不是从dict继承的主要原因是，dict有时会在某些方法的实现（C语言实现）上走一些捷径，导致我们不得不在它的子类中重写这些问题，而UserDict不存在这些问题。

class collections.UserDict（[ initialdata ] ）

实例的内容保存在常规字典中，可通过UserDict实例的data属性访问。如果提供了initialdata，则使用其内容进行对data初始化;

除了支持映射的方法和操作之外， UserDict实例还提供以下属性：

• data

  用于存储UserDict 类内容的真实字典。

UserList对象

class collections.UserList（[ list ] ）

实例的内容保存在常规列表中，可通过UserList实例的data属性访问。实例的内容最初设置为list副本，默认为空列表[]。 list可以是任何可迭代的对象，例如真正的Python列表或UserList对象。

除了支持可变序列的方法和操作之外， UserList实例还提供以下属性：

• data

  用于存储UserList 类内容的真实列表。

UserString对象

class collections.UserString（seq ）

模拟字符串对象的类。实例的内容保存在常规字符串对象中，可通过实例data属性访问。实例的内容最初设置为seq的副本。

除了支持字符串的方法和操作外， UserString实例还提供以下属性：

• data

  真实str对象用于存储UserString类内容 。