collection 
　　定義命名元祖,讓元祖的每個元素可以通過類似物件屬性的方法用".屬性"及其方便的取值.
　　定義可前後拿取值且可迭代的雙端佇列
　　定義有順序的字典
　　定義有預設值的字典

ps:
　　佇列 ：先進先出
　　堆疊 ：先進後出

具體用到的或者可能用到總之都要了解的方法:
1.namedtuple: 生成可以使用名字來訪問元素內容的tuple
2.deque: 雙端佇列，可以快速的從另外一側追加和推出物件
3.Counter: 計數器，主要用來計數，只能計算字串，沒啥用，滾滾滾一邊玩去
4.OrderedDict: 有序字典
5.defaultdict: 帶有預設值的字典

需要用到的模組

1
 
 import collections    

namedtuple: 定義命名元祖

1 from collections import namedtuple                # 當只用namedtuple的時候可以只調用這個方法
2 Point = namedtuple("point",["x","y","z"])     　　# 只引入方法的時候可以直接用方法就可以，引入模組需要先呼叫模組在調方法
3                                                 # 起個名字需要，後面要
4 p = Point(1,2,3)             　　　　　　　　　　 #
 
 必須與你定義的時候的一一對應,不可多不可少
5 print(p.x)    # 1
6 print(p.y)    # 2
7 print(p)    　 # 3

簡單的小示例
　　花色和數字

1 Card = namedtuple("card",["suits","number"])
2 c1 = Card("紅心",2)
3 print(c1)            # card(suits='紅心', number=2)
4 print(c1.number)     # 2
5 print(c1.suits)      # 紅心

再說 deque之前先說修下 普通的佇列 queue
　　佇列 
　　　　先進先出FIFO  
　　　　佇列不能迴圈 
　　　　不是迭代器 
　　　　無法用for 　　　　# TypeError: 'Queue' object is not iterable
　　　　也無法插入內容

 1 import queue
 2 q = queue.Queue()            # 定義一個佇列
 3 q.put(10)                    # put不能放多個值,一次只能放一個值
 4 q.put(5)
 5 q.put(6)
 6 print(q.qsize())    　　　　　# 3        # 檢視佇列的大小
 7 # for i in q:               # 直接標黃 是不可迭代的
 8 #     print(i)            　# TypeError: 'Queue' object is not iterable
 9 print(q)             　　#<queue.Queue object at 0x00000000023E60F0>        # 無法檢視的，只能看到記憶體地址
10 print(q.get())        # 10
11 print(q.get())        # 5
12 print(q.get())        # 6
13 print(q.get())           # 阻塞，沒資料可拿。直到你給我一個值我才繼續走

雙端佇列 
　　可以從前拿 
　　從後拿 
　　從前新增 
　　從後新增 
　　不能從中間拿　　
　　可以通過索引的方式指定位置新增,即可以中間加值
　　可迭代 
　　可for 迴圈 

 1 from collections import deque
 2 dq = deque([1,2])
 3 dq.append("a")           # 從後面放資料    [1,2,"a"]
 4 dq.appendleft("b")       # 從前面放資料    ["b",1,2,"a"]
 5 dq.insert(1,3)            # 在索引1的位置插入資料     deque(['b', 3, 1, 2, 'a'])
 6 print(dq)
 7 print(dq.pop())            # 從後面彈出
 8 print(dq.popleft())        # 從前面彈出
 9 print(dq)               # deque([3, 1, 2])  # 是可以看到裡面的內容的，不太安全啊
10 for i in dq:            # 雙端佇列是可以迭代的
11     print(i)            # 3 1 2

有序字典:
　　用OrderedDict會根據放入元素的 先後順序 進行排序

 1 from collections import OrderedDict
 2 # # 普通的字典是無序的輸出是隨機資料
 3 d = dict([("a",1),("b",2),("c",3)])    　　　　# 是不是覺得這種字典定義方式很陌生,其實我也覺得,挺麻煩的.
 4 print(d.values())        　　　　　　　　　　　　 #     1 3 2
 5 od = OrderedDict([("a",1),("b",2),("c",3)])   # 並不是說非要用這種方式建立 
 6 
 7 # a = OrderedDict()                # 用這種建立之後再加鍵值對的方式也是可以的
 8 # print(a)    # OrderedDict()
 9 # a["a"] ="lalal"
10 # print(a)    # OrderedDict([('a', 'lalal')])
11 
12 print(od.items())     # odict_items([('a', 1), ('b', 2), ('c', 3)])
13 print(od.values())    # odict_values([1, 2, 3])
14 for k,v in od.items():　 # 是可以迭代的
15     print(k)
16     print(v)
17 # a
18 # 1
19 # b
20 # 2
21 # c
22 # 3

　　關於有序字典需要注意的是:
　　　　不同順序的有序字典儘管值相同,但是順序不同也會被認為是不同的有序字典

 1 print ('Regular dictionary:')
 2 d2={}
 3 d2['a']='A'
 4 d2['b']='B'
 5 d2['c']='C'
 6 d3={}
 7 d3['c']='C'
 8 d3['a']='A'
 9 d3['b']='B'
10 print(d2 == d3)    # True
11 
12 print ('\nOrderedDict:')
13 d4=collections.OrderedDict()
14 d4['a']='A'
15 d4['b']='B'
16 d4['c']='C'
17 d5=collections.OrderedDict()
18 d5['c']='C'
19 d5['a']='A'
20 d5['b']='B'
21 print  (d4==d5)    # False

defaultdict 帶預設值的字典
　　用於規避 取字典中不存在的鍵值對會導致報錯的問題　　
　　　　　　　在取不存在的值的時候 返回一個預設值避免報錯

 1 from collections import defaultdict
 2 a = dict([("a",1),("b",2)])
 3 print(a["a"])    # 1
 4 print(a["b"])    # 2
 5 # print(a["c"])    # KeyError: 'c'
 6 a = defaultdict(lambda :"不存在的值",[("a",1),("b",2)])         # defaultdict的預設值可以是任何，字典元祖都可以，
 7 # a = defaultdict(5,[("a",1),("b",2)])         # TypeError: first argument must be callable or None
 8                                             　　# 但是就是不能為一個確定值，想要確定值作為預設值，可以用匿名函式直接返回
 9 print(a["a"])    # 1
10 print(a["b"])    # 2
11 print(a["c"])    # 不存在的值