1.collections：
1）counter： Counter 作为字典(dict)的一个子类用来进行hashtable计数，将元素进行数量统计、计数后返回一个字典,键值为元素：值为元素个数
# -*- coding: utf-8 -*-
from collections import *
print '----------counter------------'
# Counter 作为字典(dict)的一个子类用来进行hashtable计数，将元素进行数量统计、计数后返回一个字典,键值为元素：值为元素个数
s = 'abcbcaccaaabbbad'
l = ['a','b','c','c','a','b','b']
d = {'2': 3, '3': 2, '7': 2}
# Counter 获取各元素的个数,返回字典
print Counter(s) # Counter({'c': 4, 'b': 4, 'a': 3})
print Counter(l) # Counter({'b': 3, 'a': 2, 'c': 2})
print Counter(d) # Counter({'2': 3, '3': 2, '7': 2})
print '---------most_common---------'
# most_common(int) 按照元素出现的次数进行从高到低的排序,返回前int个元素的字典
m1 = Counter(s)
print m1 # Counter({'c': 4, 'b': 4, 'a': 3, 'd': 1})
print m1.most_common(3) # [('c', 4), ('b', 4), ('a', 3)]
print '----------elements-----------'
# elements 返回经过计数器Counter后的元素,返回的是一个迭代器
e1 = Counter(s)
print e1.elements()
print sorted(e1.elements())
print ''.join(sorted(e1.elements())) # aaabbbbcccc
e2 = Counter(d)
print sorted(e2.elements()) # ['7', '7', '2', '2', '2', '3', '3'] 字典返回value个key
print '-----------update------------'
# update 和set集合的update一样,对集合进行并集更新
u1 = Counter(l)
u1.update('3a')
print u1 # Counter({'a': 3, 'b': 3, 'c': 2, '3': 1})
print '----------substract----------'
# substract 和update类似，只是update是做加法，substract做减法,从另一个集合中减去本集合的元素，
sub1 = 'which'
sub2 = 'whatw'
subset = Counter(sub1)
print subset # Counter({'h': 2, 'i': 1, 'c': 1, 'w': 1})
subset.subtract(Counter(sub2))
print subset # Counter({'c': 1,'i': 1,'h': 1,'a': -1,'t': -1,'w': -1}) sub1中的h变为2,sub2中h为1,减完以后为1
print '----------------------------'
s1 = Counter(s)
# <dictionary-itemiterator object at 0x0000000005C1BA48> [('a', 6), ('c', 4), ('b', 5), ('d', 1)]
print s1.iteritems(),[i for i in s1.iteritems()]
print s1.iterkeys() # <dictionary-keyiterator object at 0x0000000005C1BA48>
print s1.itervalues() # <dictionary-valueiterator object at 0x0000000005C1BA48>
2）deque：包含在文件_collections.py中,属于高性能的数据结构(High performance data structures)之一.可以从两端添加和删除元素,常用的结构是它的简化版
# -*- coding: utf-8 -*-
from collections import *
print '------------deque-----------'
str1 = 'abc1d'
dq = deque(str1)
print dq # deque(['a', 'b', 'c', '1', 'd'])
print '------------append-----------'
# 队列右边添加元素
dq.append('e')
print dq # deque(['a', 'b', 'c', '1', 'd', 'e'])
print '----------appendleft---------'
# 队列左边添加元素
dq.appendleft('s')
print dq # deque(['s', 'a', 'b', 'c', '1', 'd', 'e'])
print '-------------count-----------'
# count(value) 返回队列中包含value的个数,结果类型为 integer
print dq.count('a') # 1
print '-------------extend-----------'
# extend 队列右边扩展,可以是列表、元组或字典,如果是字典则将字典的key加入到deque
dq.extend({'a':'aaa','bb':'bbbb'})
print dq # deque(['s', 'a', 'b', 'c', '1', 'd', 'e', 'a', 'bb'])
print '----------extendleft----------'
# 同extend, 在左边扩展
dq.extendleft('L')
print dq # deque(['L', 's', 'a', 'b', 'c', '1', 'd', 'e', 'a', 'bb'])
print '--------------pop-------------'
# pop 移除并且返回队列右边的元素
print dq.pop() # bb
print dq # deque(['L', 's', 'a', 'b', 'c', '1', 'd', 'e', 'a'])
print '------------popleft-----------'
# popleft 移除并且返回队列左边的元素
print dq.popleft() # L
print dq # deque(['s', 'a', 'b', 'c', '1', 'd', 'e', 'a'])
print '------------remove------------'
# remove(value) 移除队列第一个出现的元素（从左往右开始的第一次出现的元素value)
print dq.remove('a') # None
print dq # deque(['s', 'b', 'c', '1', 'd', 'e', 'a'])
print '------------reverse-----------'
# reverse 队列的所有元素进行反转
dq.reverse() # deque(['a', 'e', 'd', '1', 'c', 'b', 's'])
print dq
print '------------rotate------------'
# rotate(n) 对队列的数进行移动,若n<0,则往左移动即将左边的第一个移动到最后,移动n次,n>0 往右移动
dq.rotate(2)
print dq # deque(['b', 's', 'a', 'e', 'd', '1', 'c'])
3）defaultdict：默认字典,是字典的一个子类,继承有字典的方法和属性,默认字典在进行定义初始化的时候可以指定字典值得默认类型
# -*- coding: utf-8 -*-
from collections import *
people = [['male', 'winter'], ['female', 'elly'], ['male', 'frank'], ['female', 'emma']]
gender_sort = defaultdict(list)
for info in people:
gender_sort[info[0]].append(info[1])
#结果defaultdict(<class 'list'>, {'male': ['winter', 'frank'], 'female': ['elly', 'emma']})
print gender_sort4）OrderedDict：字典顺序将按照录入顺序进行排序且不会改变
# -*- coding: utf-8 -*-
from collections import *
# 定义传统字典
dic1 = dict()
# 按顺序添加字典内容
dic1['a'] = '123'
dic1['b'] = 'jjj'
dic1['c'] = '394'
dic1['d'] = '999'
print dic1 # {'a': '123', 'c': '394', 'b': 'jjj', 'd': '999'}
# 定义有序字典
dic2 = OrderedDict()
dic2['a'] = '123'
dic2['b'] = 'jjj'
dic2['c'] = 'abc'
dic2['d'] = '999'
print dic2 # OrderedDict([('a', '123'), ('b', 'jjj'), ('c', 'abc'), ('d', '999')])
5）namedtuple：可命名元组，给元组每个元素起一个名字，这样就可以通过名字来访问元组里的元素，增强了可读性；尤其对于座标，html标签的长宽等，使用名字可读性更强；有点类似于字典了
# -*- coding: utf-8 -*-
from collections import *
#创建一个nametuplede 类,类名称为Person，并赋给变量P
P = namedtuple('Person', 'name,age,gender')
print 'Type of Person:', type(P) # Type of Person: <type 'type'>
#通过Person类实例化一个对象bob
bob = P(name='Bob', age=30, gender='male')
print '\nRepresentation:', bob # Representation: Person(name='Bob', age=30, gender='male')
#通过Person类实例化一个对象jane
jane = P(name='Jane', age=29, gender='female')
print '\nField by name:', jane.name # Field by name: Jane
print '\nFields by index:'
for p in [bob, jane]:
print '%s is a %d year old %s' % p2.heapq：
1）堆定义：堆是一种特殊的树形数据结构，每个节点都有一个值，通常我们所说的堆的数据结构指的是二叉树。堆的特点是根节点的值最大（或者最小），而且根节点的两个孩子也能与孩子节点组成子树，亦然称之为堆。堆分为两种，大根堆和小根堆是一颗每一个节点的键值都不小于（大于）其孩子节点的键值的树。无论是大根堆还是小根堆（前提是二叉堆）都可以看成是一颗完全二叉树。下面以图的形式直观感受一下
# -*- coding: utf-8 -*-
import heapq
hq = []
print '---------------heappush--------------'
# heappush(heap,item) # 往堆中插入一条新的值
heapq.heappush(hq,'b')
heapq.heappush(hq,'c')
heapq.heappush(hq,'d')
heapq.heappush(hq,'a')
print hq # ['a', 'b', 'd', 'c']
print '---------------heappop---------------'
item = heapq.heappop(hq) # 从堆中弹出最小值
print item # a
print hq # ['b', 'c', 'd']
print '-------------------------------------'
small = hq[0] # 查看堆中最小值,不弹出(第一个肯定是最小值)
print small # b
print '-----------------merge---------------'
# merge(*iterables) #合并多个堆然后输出
print list(heapq.merge([1,3,5,7],[0,2,4,8],[5,10,15,20],[],[25]))
# [0, 1, 2, 3, 4, 5, 5, 7, 8, 10, 15, 20, 25]
print '---------------nlargest--------------'
# nlargest(n , iterbale, key=None) 找到堆中最大的N个数
b = [('a',1),('b',2),('c',3),('d',4),('e',5)]
print heapq.nlargest(1,b,key=lambda x:x[1]) # [('e', 5)]
print '---------------nsmallest--------------'
# nsmallest(n, iterable, key=None) #找到堆中最小的N个数
c = [('a',1),('b',2),('c',3),('d',4),('e',5)]
print heapq.nsmallest(2,c,key=lambda x:x[1]) # [('a', 1), ('b', 2)]
print '----------------heapify---------------'
# heapify() # 列表转化成堆
l1 = [2,3,4,0,1,5,9,6,7]
heapq.heapify(l1)
print l1 # [0, 1, 4, 3, 2, 5, 9, 6, 7]
3）queue：参考：https://blog.csdn.net/hehe123456zxc/article/details/52275821;https://www.cnblogs.com/zhouxinfei/p/7875900.html
# -*- coding: utf-8 -*-
import Queue
print '------------Queue------------'
# FIFO队列先进先出:queue.queue(maxsize)
q1 = Queue.Queue(maxsize=3)
q1.put(1)
q1.put(2)
q1.put(3)
print q1.qsize() # 3
print q1.get() # 1
print q1.get() # 2
print '----------LifoQueue----------'
# LIFO类似于堆。即先进后出
q2 = Queue.LifoQueue(maxsize=3)
q2.put(1)
q2.put(2)
q2.put(3)
print q2.qsize() # 3
print q2.get() # 3
print q2.get() # 2
print '---------PriorityQueue--------'
# 优先级队列级别越低越先出来
q3 = Queue.PriorityQueue(maxsize=3)
q3.put(1)
q3.put(2)
q3.put(3)
print q3.qsize() # 3
print q3.get() # 1
print q3.get() # 2