摘要：總結以上這些在日常使用的時候如果不了解，很少會去用到，但如果想寫出優雅，簡潔的代碼，這些概念會起到一定的幫助作用參考

collections 數據類型主要是為了彌補 list /tuple / dict 的額外數據類型

代碼：

import collections
## 賦值，合并字典的作用
a = {"a":"A"}
b = {"b":"B"}

m = collections.ChainMap(a,b)
for k,v in m.items():
    print("key: {} | value:{}".format(k,v))

print(m)

如果字典中有重復的key值

a = {"a":"A","b":"B"}
b = {"b":"C"}
m2 = collections.ChainMap(a,b)
print(m2)

for k,v in m2.items():
    print("key: {} | value:{}".format(k,v))

輸出：

ChainMap({"a": "A", "b": "B"}, {"b": "C"})
key: a | value:A
key: b | value:B

結論：
結果是沒有合并，如果只是合并字典的值，還是直接使用update即可, 這個模塊不怎么會用到，了解即可

Counter 顧名思義，就是計算總數的意思，可以計算出一個序列中每個元素的個數，一個簡單的例子

>>> import collections
>>> collections.Counter("Hello World")
Counter({"l": 3, "o": 2, "H": 1, "e": 1, " ": 1, "W": 1, "r": 1, "d": 1})

可以使用如下的寫法，來得到自己想要的元素的個數

>>> a =  collections.Counter("Hello World")
>>> a["W"]
1

除此之外，Counter對象還支持直接運算

import collections

c1 = collections.Counter("Hello World")
c2 = collections.Counter("Hello Python")

print("c1 + c2 =",c1 + c2)
print("c1 - c2 = ",c1 - c2)
print("c1 | c2 = ",c1 | c2)
print("c1 & c2 = ",c1 & c2)

輸出：

c1 + c2 = Counter({"l": 5, "o": 4, "H": 2, "e": 2, " ": 2, "W": 1, "r": 1, "d": 1, "P": 1, "y": 1, "t": 1, "h": 1, "n": 1})
c1 - c2 =  Counter({"l": 1, "W": 1, "r": 1, "d": 1})
c1 | c2 =  Counter({"l": 3, "o": 2, "H": 1, "e": 1, " ": 1, "W": 1, "r": 1, "d": 1, "P": 1, "y": 1, "t": 1, "h": 1, "n": 1})
c1 & c2 =  Counter({"l": 2, "o": 2, "H": 1, "e": 1, " ": 1})

眾所周知，當需要獲取一個字典的值，可以使用 xx[key] 這樣的形式去獲取，如果key值不存在，那么就會拋出一個錯誤，所以大部分推薦的做法是，使用 get 方法來獲取字典的值，比如：

test = {"a":"b"}
test.get("a")
# 如果獲取一個不存在的 key 值
test.get("b") # 返回None
# 但是通過get 可以指定一個 key 值
test.get("b","this is b") # 返回 this is b

defaultdict 也差不多是這樣的道理，當你獲取一個不存在的 key 值的時候，返回默認值

import collections

def default_value():
    return "Default value"


m = collections.defaultdict(default_value,foo="aaa")
print(m["fxx"]) # 返回 Default value

雙端隊列，元素可以從兩端彈出，插入和刪除操作限定在隊列的兩邊進行

from collections import deque
d = deque("abcdefg")
print(d) # deque(["a", "b", "c", "d", "e", "f", "g"])
d.remove("c")
print(d) # deque(["a", "b", "d", "e", "f", "g"])
d.append("h")
print(d) #deque(["a", "b", "d", "e", "f", "g", "h"])
d.appendleft("1")
print(d) #deque(["1", "a", "b", "d", "e", "f", "g", "h"])
# 使用pop 獲取隊列中的值
d.pop()
print(d) # deque(["1", "a", "b", "d", "e", "f", "g"])
d.popleft()
print(d) # deque(["a", "b", "d", "e", "f", "g"])

也可以使用線程來消費雙端隊列

from collections import deque
import time
import threading


# deque 也可以用線程通信
d1 = deque(range(1000))
def task(direction,i,nextSource):
    while True:
        try:
            item = nextSource()
            print("方向：{} 線程： {} 正在處理： {} ".format(direction,i,item))
        except IndexError as e:
            break
        else:
            time.sleep(1)
    

right_ts = [threading.Thread(target=task,args=("right",i,d1.pop))for i in range(10)]
left_ts = [threading.Thread(target=task,args=("left",i,d1.popleft)) for i in range(10)]

for tl in left_ts:
    tl.start()

for tr in right_ts:
    tr.start()

for tl in left_ts:
    tl.join()

for tr in right_ts:
    tr.join()

使用字典的時候，其輸出時，不一定按照當時添加的順序輸出，例如：

d = {}
d["a"]= "A"
d["b"] = 3
d["c"]= 1
d["d"]="B"
d["c"]="C"
for k,v in d.items():
    print(k,"=>",v)

輸出：

a => A
b => 3
c => C
d => B

但是 OrderedDict 會

d = OrderedDict()
d["a"]= "A"
d["b"] = 3
d["s"]= 1
d["d"]="B"
d["c"]="C"
for k,v in d.items():
    print(k,"=>",v)

輸出：

a => A
b => 3
s => 1
d => B
c => C

當需要使用dict 來作為運算和存儲的時候，這就是一個比較有用的特點了。

以上這些在日常使用的時候如果不了解，很少會去用到，但如果想寫出優雅，簡潔的代碼，這些概念會起到一定的幫助作用

《The Python3 Standard Library By Example》