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

  • Counter（计数器）：dict子类，用于计算可哈希性对象的个数。
  • OrderedDict（有序字典）：dict 子类，记录着数据成员添加的顺序。
  • defaultdict(默认字典）：dict 子类，调用一个工厂函数来为dict的values值缺失提供一个默认值。
  • namedtuple(可命名元组）：工厂函数生成有命名字段的tuple子类。
  • deque(双向队列）：能在“队列”两端快速出队、入队的函数，类似于队列的（list-like）的容器。
  • ChainMap:为多个映射创建单一视图的类字典类型。
  • UserDict：将字典包裹起来使得创建字典的子类更容易。
  • UserList：将列表对象包裹起来使得创建列表的子类更容易。
  • UserString：将字符串对象包裹起来使得创建字符串的子类更容易。

参考网页：https://docs.python.org/3.5/library/collections.html

 

1.计数器（counter）

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

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

 Counter

1）计数器的创建

from collections import Counter    #Counter 需要申明

a=Counter()                            # 创建空计数器
b=Counter(\'aabbbcccc\')                 # 可迭代对象计数的方式创建对象
c = Counter({\'red\': 4, \'blue\': 2})     # 映射方法创建计数器
d = Counter(cats=4, dogs=8)            # 键值的方法创建计数器

2)计数器元素的删除

 del

3)计数器的部分功能属性

most_common(self, n=None):

把计数器转化成列表，元素转化成元组，返回n个最常见的元素及其计数的列表，从最常见到最少见。如果省略n或为None，most_common()返回计数器中所有元素。具有相等计数的元素是任意排序的。

 demo

elements(self):

返回一个迭代器，对元素重复迭代其计数次。元素以随机顺序返回。如果元素的计数小于1，elements()将忽略它。

 demo

update(*args, **kwds):

元素从一个可迭代对象计数或从另一个映射（或计数器）增加。类似dict.update()，但增加计数，而不是替换它们。此外，可迭代对象应为一系列元素，而不是(key, value)对。

 demo
subtract(*args, **kwds):
从一个可迭代对象或另一个映射（或计数器）中减去元素。类似dict.update()，但减去计数，而不是替换它们。输入和输出都可以为零或负。
 demo

2.有序字典(OrderedDict )
有序字典与常规字典类似，但它们记住键值对插入的顺序。当对有序字典进行迭代时，项目按它们的键首次添加的顺序返回。
 OrderedDict
1）有序字典的创建：
 demo
2）有序字典的功能：
有序字典继承了字典的功能，下面只介绍与字典不同功能。
popitem(self, last=True):
返回并删除字典中的键值对。如果last为True（默认值），则以LIFO顺序返回这些键值对，如果为False，则以FIFO顺序返回。
 demo
move_to_end(self, key, last=True):
将一个已存在key移动到有序字典的另一端。如果last为True（默认值），则项目移动到末尾，如果last为False，则移动到开始。如果key不存在，引发KeyError。
 demo

3.默认字典(defaultdict) 
defaultdict可以把字典指定一个默认value，可以是字典/列表等。返回一个新的类似字典的对象，功能与dict类相同。
如：
 demo
应用：
 demo

默认字典的功能：

 defaultdict


4.可命名元组(namedtuple) 

1）可命名元组的说明

给元组中每个位置上的元素命名，它们可以使用常规的元组方法，可以让访问元素可以按名称而不是按位置索引。

collections.namedtuple(typename, field_names, verbose=False, rename=False)：

返回一个叫做 typename 的tuple子类，这个新的子类用来创建类tuple(tuple-like)的对象，这个对象拥有可以通过属性访问的字段，并且可以通过下标索引和迭代。

field_names 是一个单独的字符串，这个字符串中包含的所有字段用空格或逗号隔开，例如 \'xy\' 或 \'x,y\'.另外, field_names 也可以是字符串的列表，例如 [\'x\', \'y\']。

如果verbose 为 True, 在类被建立后将打印类的定义。相反，它打印的是类的 _source 属性，也就是打印源代码。

如果 rename参数 为 True, 无效的field_names会被自动转换成位置的名称.例如, [\'abc\', \'def\', \'ghi\', \'abc\'] 将被转换为 [\'abc\', \'_1\', \'ghi\',\'_3\'], 来消除关键字 def 和重复的字段名 abc。

2）可命名元组的创建

需要先创建一个类。

复制代码
from collections import namedtuple

myTupleClass=namedtuple(\'myTupleClass\',[\'x\',\'y\'])
a=point(1,2)
b=point(2,0)
print(a,a.x,a.y,type(a))
print(b,b.x,b.y,type(b))

#运行结果
myTupleClass(x=1, y=2) 1 2 <class \'__main__.myTupleClass\'>
myTupleClass(x=2, y=0) 2 0 <class \'__main__.myTupleClass\'>
复制代码

3）可命名元组新创建类的功能属性

如上面创建的myTupleCalss类： 

 myTupleCalss

 

5.队列(deque)

1）双向队列（deque)

双向队列（Deque）是栈和队列的一般化。可以在两端添加和删除元素。

双向队列的创建：

复制代码
from collections import deque

a=deque()
b=deque(\'abcd\')
print(a,type(a))
print(b,type(b))

#运行结果
deque([]) <class \'collections.deque\'>
deque([\'a\', \'b\', \'c\', \'d\']) <class \'collections.deque\'>
复制代码

双向队列的功能属性：

 deque

2)单向队列（queue.Queue)

class queue.Queue(maxsize=0)

单向队列与双向队列的区别是FIFO（先进先出），maxsize是个整数，指明了队列中能存放的数据个数的上限。一旦达到上限，插入会导致阻塞，直到队列中的数据被取出。如果maxsize小于或者等于0，则队列大小没有限制。

单向队列的创建：

复制代码
import queue

a=queue.Queue()
b=queue.Queue(\'abcd\')
print(a,type(a))
print(b,type(b))

#运行结果
<queue.Queue object at 0x00FBB310> <class \'queue.Queue\'>
<queue.Queue object at 0x01522DF0> <class \'queue.Queue\'>
复制代码

单向队列的功能属性：

 queue.Queue