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