內置模塊 I

1. 序列化模塊

我們今天學習下序列化,什么是序列化呢? 序列化的本質就是將一種數據結構（如字典、列表)等轉換成一個特殊的序列（字符串或者bytes）的過程就叫做序列化。那么有同學就會問了，為什么要轉化成這個序列，我們不是學過么？

dic = {'name': '太白金星'}
​
ret = str(dic)
​
print(ret,type(ret))  

首先你要看清楚！我說的是一個特殊的序列，而不是我們常用的str這種字符串。

為什么要有序列化模塊？

其次，將這個數據結構轉化成這個特殊的序列有什么用呢？ 這個才是序列化的關鍵所在，這個特殊的序列大有用處。舉例說明：

比如，你的程序中需要一個字典類型的數據存放你的個人信息：

 dic = {'username':'太白', 'password': 123,'login_status': True}

　　你的程序中有一些地方都需要使用這個dic數據，登錄時會用到，注冊時也會用到。那么我們之前就是將這個dic寫在全局里，但是這樣是不合理的，應該是將這數據寫入一個地方存儲（還沒有學數據庫）先存放在一個文件中，那么程序中哪里需要這個數據了，你就讀取文件取出你需要的信息即可。那么有沒有什么問題？ 你將這個字典直接寫入文件是不可以的，必須轉化成字符串的形式，而且你讀取出來也是字符串形式的字典（可以用代碼展示）。

那么你拿到一個str(dic)有什么用？他是根本轉化不成dic的（不能用eval很危險），所以很不方便。那么這時候序列化模塊就起到作用了，如果你寫入文件中的字符串是一個序列化后的特殊的字符串，那么當你從文件中讀取出來，是可以轉化回原數據結構的。這個就很牛逼了。

下面說的是json序列化，pickle序列化有所不同。

json序列化除了可以解決寫入文件的問題，還可以解決網絡傳輸的問題，比如你將一個list數據結構通過網絡傳給另個開發者，那么你不可以直接傳輸，之前我們說過，你要想傳輸出去必須用bytes類型。但是bytes類型只能與字符串類型互相轉化，它不能與其他數據結構直接轉化，所以，你只能將list ---> 字符串 ---> bytes 然后發送，對方收到之后，在decode() 解碼成原字符串。此時這個字符串不能是我們之前學過的str那種字符串，因為它不能反解，必須要是這個特殊的字符串，他可以反解成list 這樣開發者之間就可以借助網絡互傳數據了，不僅僅是開發者之間，你要借助網絡爬取數據這些數據多半是這種特殊的字符串，你接受到之后，在反解成你需要的數據類型。

對於這個序列化模塊我們做一個小小總結：

序列化模塊就是將一個常見的數據結構轉化成一個特殊的序列，並且這個特殊的序列還可以反解回去。它的主要用途：文件讀寫數據，網絡傳輸數據。

Python中這種序列化模塊有三種：

    json模塊 ： （重點）

1. 不同語言都遵循的一種數據轉化格式，即不同語言都使用的特殊字符串。（比如Python的一個列表[1, 2, 3]利用json轉化成特殊的字符串，然后在編碼成bytes發送給php的開發者，php的開發者就可以解碼成特殊的字符串，然后在反解成原數組(列表): [1, 2, 3]）

2. json序列化只支持部分Python數據結構：dict,list, tuple,str,int, float,True,False,None

  

    pickle模塊：

1. 只能是Python語言遵循的一種數據轉化格式，只能在python語言中使用。

2. 支持Python所有的數據類型包括實例化對象。

    

    shelve模塊：類似於字典的操作方式去操作特殊的字符串（不講，可以課下了解）。

當然序列化模塊中使用最多的的就是json模塊，那么接下來，我們講一下json與pickle模塊。

1.1 json模塊

json模塊是將滿足條件的數據結構轉化成特殊的字符串，並且也可以反序列化還原回去。

上面介紹我已經說過了，序列化模塊總共只有兩種用法，要不就是用於網絡傳輸的中間環節，要不就是文件存儲的中間環節，所以json模塊總共就有兩對四個方法：

    用於網絡傳輸：dumps、loads

    用於文件寫讀：dump、load

dumps、loads

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：將一個字典轉換成一個字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json轉換完的字符串類型的字典中的字符串是由""表示的
​
dic2 = json.loads(str_dic)  #反序列化：將一個字符串格式的字典轉換成一個字典
#注意，要用json的loads功能處理的字符串類型的字典中的字符串必須由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
​
​
list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以處理嵌套的數據類型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

dump、load

import json
f = open('json_file.json','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一個文件句柄，直接將字典轉換成json字符串寫入文件
f.close()
# json文件也是文件，就是專門存儲json字符串的文件。
f = open('json_file.json')
dic2 = json.load(f)  #load方法接收一個文件句柄，直接將文件中的json字符串轉換成數據結構返回
f.close()
print(type(dic2),dic2)

其他參數說明

ensure_ascii:，當它為True的時候，所有非ASCII碼字符顯示為\uXXXX序列，只需在dump時將ensure_ascii設置為False即可，此時存入json的中文即可正常顯示。 separators：分隔符，實際上是(item_separator, dict_separator)的一個元組，默認的就是(‘,’,’:’)；這表示dictionary內keys之間用“,”隔開，而KEY和value之間用“：”隔開。 sort_keys：將數據根據keys的值進行排序。 剩下的自己看源碼研究

json序列化存儲多個數據到同一個文件中

對於json序列化，存儲多個數據到一個文件中是有問題的，默認一個json文件只能存儲一個json數據，但是也可以解決，舉例說明：

對於json 存儲多個數據到文件中
dic1 = {'name':'oldboy1'}
dic2 = {'name':'oldboy2'}
dic3 = {'name':'oldboy3'}
f = open('序列化',encoding='utf-8',mode='a')
json.dump(dic1,f)
json.dump(dic2,f)
json.dump(dic3,f)
f.close()
​
f = open('序列化',encoding='utf-8')
ret = json.load(f)
ret1 = json.load(f)
ret2 = json.load(f)
print(ret)

上面會報錯

解決方式：

dic1 = {'name':'oldboy1'}
dic2 = {'name':'oldboy2'}
dic3 = {'name':'oldboy3'}
f = open('序列化',encoding='utf-8',mode='a')
str1 = json.dumps(dic1)
f.write(str1+'\n')
str2 = json.dumps(dic2)
f.write(str2+'\n')
str3 = json.dumps(dic3)
f.write(str3+'\n')
f.close()
​
f = open('序列化',encoding='utf-8')
for line in f:
    print(json.loads(line))

1.2 pickle模塊

pickle模塊是將Python所有的數據結構以及對象等轉化成bytes類型，然后還可以反序列化還原回去。

    剛才也跟大家提到了pickle模塊，pickle模塊是只能Python語言識別的序列化模塊。如果把序列化模塊比喻成全世界公認的一種交流語言，也就是標准的話，json就是像是英語，全世界（python，java，php，C，等等）都遵循這個標准。而pickle就是中文，只有中國人（python）作為第一交流語言。

    既然只是Python語言使用，那么它支持Python所有的數據類型包括后面我們要講的實例化對象等，它能將這些所有的數據結構序列化成特殊的bytes，然后還可以反序列化還原。使用上與json幾乎差不多，也是兩對四個方法。

    用於網絡傳輸：dumps、loads

    用於文件寫讀：dump、load

dumps、loads

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  # bytes類型
​
dic2 = pickle.loads(str_dic)
print(dic2)    #字典
​

# 還可以序列化對象
import pickle
​
def func():
    print(666)
    
ret = pickle.dumps(func)
print(ret,type(ret))  # b'\x80\x03c__main__\nfunc\nq\x00.' <class 'bytes'>
​
f1 = pickle.loads(ret)  # f1得到 func函數的內存地址
f1()  # 執行func函數

dump、load

dic = {(1,2):'oldboy',1:True,'set':{1,2,3}}
f = open('pick序列化',mode='wb')
pickle.dump(dic,f)
f.close()
with open('pick序列化',mode='wb') as f1:
    pickle.dump(dic,f1)
​
​

pickle序列化存儲多個數據到一個文件中

dic1 = {'name':'oldboy1'}
dic2 = {'name':'oldboy2'}
dic3 = {'name':'oldboy3'}
​
f = open('pick多數據',mode='wb')
pickle.dump(dic1,f)
pickle.dump(dic2,f)
pickle.dump(dic3,f)
f.close()
​
f = open('pick多數據',mode='rb')
while True:
    try:
        print(pickle.load(f))
    except EOFError:
        break
f.close()

    這時候機智的你又要說了，既然pickle如此強大，為什么還要學json呢？這里我們要說明一下，json是一種所有的語言都可以識別的數據結構。如果我們將一個字典或者序列化成了一個json存在文件里，那么java代碼或者js代碼也可以拿來用。但是如果我們用pickle進行序列化，其他語言就不能讀懂這是什么了～所以，如果你序列化的內容是列表或者字典，我們非常推薦你使用json模塊，但如果出於某種原因你不得不序列化其他的數據類型，而未來你還會用python對這個數據進行反序列化的話，那么就可以使用pickle。

可參考processon流程圖：https://www.processon.com/diagraming/5cb8278ce4b085d0107b2d38

2. os模塊

os模塊是與操作系統交互的一個接口,它提供的功能多與工作目錄，路徑，文件等相關。接下來這些方法我會帶着大家演示一遍，重點的一些方法最好記住，剩下的記好筆記，以后需要時隨時查閱即可。

講這些方法前先給大家普及一下專用名詞：

目錄指的是:文件夾 當前目錄，工作目錄，父級目錄：指的都是一個，就是本文件所在的文件夾。

接下來帶着學生講解下面的這些方法：按照星的等級划分,三顆星是需要記住的。

當前執行這個python文件的工作目錄相關的工作路徑
os.getcwd() 獲取當前工作目錄，即當前python腳本工作的目錄路徑  ** 
os.chdir("dirname")  改變當前腳本工作目錄；相當於shell下cd  **
os.curdir  返回當前目錄: ('.')  **
os.pardir  獲取當前目錄的父目錄字符串名：('..') **
​
# 和文件夾相關 
os.makedirs('dirname1/dirname2')    可生成多層遞歸目錄  ***
os.removedirs('dirname1') 若目錄為空，則刪除，並遞歸到上一級目錄，如若也為空，則刪除，依此類推 ***
os.mkdir('dirname')    生成單級目錄；相當於shell中mkdir dirname ***
os.rmdir('dirname')    刪除單級空目錄，若目錄不為空則無法刪除，報錯；相當於shell中rmdir dirname ***
# os.listdir('dirname')    列出指定目錄下的所有文件和子目錄，包括隱藏文件，並以列表方式打印 **
​
# 和文件相關
os.remove()  刪除一個文件  ***
os.rename("oldname","newname")  重命名文件/目錄  ***
os.stat('path/filename')  獲取文件/目錄信息 **
​
# 和操作系統差異相關
# os.sep    輸出操作系統特定的路徑分隔符，win下為"\\",Linux下為"/" *
# os.linesep    輸出當前平台使用的行終止符，win下為"\t\n",Linux下為"\n" *
# os.pathsep    輸出用於分割文件路徑的字符串 win下為;,Linux下為: *
# os.name    輸出字符串指示當前使用平台。win->'nt'; Linux->'posix' *
# 和執行系統命令相關
# os.system("bash command")  運行shell命令，直接顯示  **
# os.popen("bash command).read()  運行shell命令，獲取執行結果  **
os.environ  獲取系統環境變量  **
​
#path系列，和路徑相關
os.path.abspath(path) 返回path規范化的絕對路徑  ***
os.path.split(path) 將path分割成目錄和文件名二元組返回 ***
os.path.dirname(path) 返回path的目錄。其實就是os.path.split(path)的第一個元素  **
os.path.basename(path) 返回path最后的文件名。如何path以／或\結尾，那么就會返回空值，即os.path.split(path)的第二個元素。 **
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False  ***
os.path.isabs(path)  如果path是絕對路徑，返回True  **
os.path.isfile(path)  如果path是一個存在的文件，返回True。否則返回False  ***
os.path.isdir(path)  如果path是一個存在的目錄，則返回True。否則返回False  ***
os.path.join(path1[, path2[, ...]])  將多個路徑組合后返回，第一個絕對路徑之前的參數將被忽略 ***
os.path.getatime(path)  返回path所指向的文件或者目錄的最后訪問時間  **
os.path.getmtime(path)  返回path所指向的文件或者目錄的最后修改時間  **
os.path.getsize(path) 返回path的大小 ***

注意：os.stat('path/filename') 獲取文件/目錄信息 的結構說明

stat 結構:
st_mode: inode 保護模式
st_ino: inode 節點號。
st_dev: inode 駐留的設備。
st_nlink: inode 的鏈接數。
st_uid: 所有者的用戶ID。
st_gid: 所有者的組ID。
st_size: 普通文件以字節為單位的大小；包含等待某些特殊文件的數據。
st_atime: 上次訪問的時間。
st_mtime: 最后一次修改的時間。
st_ctime: 由操作系統報告的"ctime"。在某些系統上（如Unix）是最新的元數據更改的時間，在其它系統上（如Windows）是創建時間（詳細信息參見平台的文檔）。

3. sys模塊

sys模塊是與python解釋器交互的一個接口，這個模塊功能不是很多，練習一遍就行。

sys.argv           命令行參數List，第一個元素是程序本身路徑
sys.exit(n)        退出程序，正常退出時exit(0),錯誤退出sys.exit(1)
sys.version        獲取Python解釋程序的版本信息
sys.path           返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值  ***
sys.platform       返回操作系統平台名稱

4. hashlib模塊

    此模塊有人稱為摘要算法，也叫做加密算法，或者是哈希算法，散列算法等等，這么多title不用大家記，那么有同學就問他到底是干啥的？ 簡單來說就是做加密和校驗使用，它的工作原理給大家簡單描述一下：它通過一個函數，把任意長度的數據按照一定規則轉換為一個固定長度的數據串（通常用16進制的字符串表示）。

比如：之前我們在一個文件中存儲用戶的用戶名和密碼是這樣的形式：

    太白|123456

有什么問題？你的密碼是明文的，如果有人可以竊取到這個文件，那么你的密碼就會泄露了。所以，一般我們存儲密碼時都是以密文存儲，比如：

    太白|e10adc3949ba59abbe56e057f20f883e

那么即使是他竊取到這個文件，他也不會輕易的破解出你的密碼，這樣就會保證了數據的安全。

hashlib模塊就可以完成的就是這個功能。

hashlib的特征以及使用要點：

1. bytes類型數據 ---> 通過hashlib算法 ---> 固定長度的字符串

2. 不同的bytes類型數據轉化成的結果一定不同。

3. 相同的bytes類型數據轉化成的結果一定相同。

4. 此轉化過程不可逆。

那么剛才我們也說了，hashlib的主要用途有兩個：

    密碼的加密。

    文件一致性校驗。

hashlib模塊就相當於一個算法的集合，這里面包含着很多的算法，算法越高，轉化成的結果越復雜，安全程度越高，相應的效率就會越低。

　　4.1 密碼的加密

普通加密：

我們以常見的摘要算法MD5為例，計算出一個字符串的MD5值：

import hashlib
​
md5 = hashlib.md5()
md5.update('123456'.encode('utf-8'))
print(md5.hexdigest())
​
# 計算結果如下：
'e10adc3949ba59abbe56e057f20f883e'
​
# 驗證：相同的bytes數據轉化的結果一定相同
import hashlib
​
md5 = hashlib.md5()
md5.update('123456'.encode('utf-8'))
print(md5.hexdigest())
​
# 計算結果如下：
'e10adc3949ba59abbe56e057f20f883e'
​
# 驗證：不相同的bytes數據轉化的結果一定不相同
import hashlib
​
md5 = hashlib.md5()
md5.update('12345'.encode('utf-8'))
print(md5.hexdigest())
​
# 計算結果如下：
'827ccb0eea8a706c4c34a16891f84e7b'

上面就是普通的md5加密，非常簡單，幾行代碼就可以了，但是這種加密級別是最低的，相對來說不很安全。雖然說hashlib加密是不可逆的加密方式，但也是可以破解的，那么他是如何做的呢？你看網上好多MD5解密軟件，他們就是用最low的方式，空間換時間。他們會把常用的一些密碼比如：123456,111111,以及他們的md5的值做成對應關系，類似於字典，

dic = {'e10adc3949ba59abbe56e057f20f883e': 123456}

然后通過你的密文獲取對應的密碼。

只要空間足夠大，那么里面容納的密碼會非常多，利用空間換取破解時間。 所以針對剛才說的情況，我們有更安全的加密方式：加鹽。

加鹽加密

    固定的鹽

什么叫加鹽？加鹽這個詞兒來自於國外，外國人起名字我認為很隨意，這個名字來源於燒烤，俗稱BBQ。我們燒烤的時候，一般在快熟的時候，都會給肉串上面撒鹽，增加味道，那么這個撒鹽的工序，外國人認為比較復雜，所以就講比較復雜的加密方式稱之為加鹽。

其實代碼非常簡單：

ret = hashlib.md5('xx教育'.encode('utf-8'))  # xx教育就是固定的鹽
ret.update('a'.encode('utf-8'))
print(ret.hexdigest())

上面的xx教育就是固定的鹽，比如你在一家公司，公司會將你們所有的密碼在md5之前增加一個固定的鹽，這樣提高了密碼的安全性。但是如果黑客通過手段竊取到你這個固定的鹽之后，也是可以破解出來的。所以，我們還可以加動態的鹽。

    動態的鹽

username = '太白金星666'
ret = hashlib.md5(username[::2].encode('utf-8'))  # 針對於每個賬戶，每個賬戶的鹽都不一樣
ret.update('a'.encode('utf-8'))
print(ret.hexdigest())

這樣，安全性能就大大提高了。

那么我們之前說了hahslib模塊是一個算法集合，他里面包含很多種加密算法，剛才我們說的MD5算法是比較常用的一種加密算法，一般的企業用MD5就夠用了。但是對安全要求比較高的企業，比如金融行業，MD5加密的方式就不夠了，得需要加密方式更高的，比如sha系列，sha1,sha224,sha512等等，數字越大，加密的方法越復雜，安全性越高，但是效率就會越慢。

ret = hashlib.sha1()
ret.update('taibaijinxing'.encode('utf-8'))
print(ret.hexdigest())
​
#也可加鹽
ret = hashlib.sha384(b'asfdsa')
ret.update('taibaijinxing'.encode('utf-8'))
print(ret.hexdigest())
​
# 也可以加動態的鹽
ret = hashlib.sha384(b'asfdsa'[::2])
ret.update('taibaijinxing'.encode('utf-8'))
print(ret.hexdigest())

不過一般我們用到MD5加密就可以了。

4.42 文件的一致性校驗

hashlib模塊除了可以用於密碼加密之外，還有一個常用的功能，那就是文件的一致性校驗。

    linux講究：一切皆文件，我們普通的文件，是文件，視頻，音頻，圖片，以及應用程序等都是文件。我們都從網上下載過資源，比如我們剛開學時讓大家從網上下載pycharm這個軟件，當時你可能沒有注意過，其實你下載的時候都是帶一個MD5或者shax值的，為什么？ 我們的網絡世界是很不安全的，經常會遇到病毒，木馬等，有些你是看不到的可能就植入了你的電腦中，那么他們是怎么來的？ 都是通過網絡傳入來的，就是你在網上下載一些資源的時候，趁虛而入，當然大部門被我們的瀏覽器或者殺毒軟件攔截了，但是還有一部分偷偷的進入你的磁盤中了。那么我們自己如何驗證我們下載的資源是否有病毒呢？這就需要文件的一致性校驗了。在我們下載一個軟件時，往往都帶有一個MD5或者shax值，當我們下載完成這個應用程序時你要是對比大小根本看不出什么問題，你應該對比他們的md5值，如果兩個md5值相同，就證明這個應用程序是安全的，如果你下載的這個文件的MD5值與服務端給你提供的不同，那么就證明你這個應用程序肯定是植入病毒了（文件損壞的幾率很低），那么你就應該趕緊刪除，不應該安裝此應用程序。

我們之前說過，md5計算的就是bytes類型的數據的轉換值，同一個bytes數據用同樣的加密方式轉化成的結果一定相同，如果不同的bytes數據（即使一個數據只是刪除了一個空格）那么用同樣的加密方式轉化成的結果一定是不同的。所以，hashlib也是驗證文件一致性的重要工具。

我將文件校驗寫在一個函數中

low版文件校驗：

def func(file):
    with open(file,mode='rb') as f1:
        ret = hashlib.md5()
        ret.update(f1.read())
        return ret.hexdigest()
​
​
print(func('hashlib_file1'))

這樣就可以計算此文件的MD5值，從而進行文件校驗。但是這樣寫有一個問題，類似我們文件的改的操作，有什么問題？如果文件過大，全部讀取出來直接就會撐爆內存的，所以我們要分段讀取，那么分段讀取怎么做呢？

hashlib還可以這樣玩：

import hashlib
# 直接 update
md5obj = hashlib.md5()
md5obj.update('太白 is a old driver'.encode('utf-8'))
print(md5obj.hexdigest())  # 900e328fa53873fb245f418d6942e41b
​
​
# 分段update
md5obj = hashlib.md5()
md5obj.update('太白 '.encode('utf-8'))
md5obj.update('is '.encode('utf-8'))
md5obj.update('a '.encode('utf-8'))
md5obj.update('old '.encode('utf-8'))
md5obj.update('driver'.encode('utf-8'))
print(md5obj.hexdigest())  # 900e328fa53873fb245f418d6942e41b
# 結果相同

那么根據上面的代碼，我們自己做一個高大上版的文件校驗。

高大上版文件校驗

校驗此版本的pycharm的sha256值是否相同。

def file_check(file_path):
    with open(file_path,mode='rb') as f1:
        sha256 = hashlib.sha256()
        while 1:
            content = f1.read(1024)
            if content:
                sha256.update(content)
            else:
                return sha256.hexdigest()
print(file_check('pycharm-professional-2019.1.1.exe'))

5. collections模塊

在內置數據類型（dict、list、set、tuple）的基礎上，collections模塊還提供了幾個額外的數據類型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可以使用名字來訪問元素內容的tuple

2.deque: 雙端隊列，可以快速的從另外一側追加和推出對象

3.Counter: 計數器，主要用來計數

4.OrderedDict: 有序字典

5.defaultdict: 帶有默認值的字典

namedtuple

我們知道tuple可以表示不變集合，例如，一個點的二維坐標就可以表示成：

p = (1, 2)

但是，看到(1, 2)，很難看出這個tuple是用來表示一個坐標的。

這時，namedtuple就派上了用場：

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

類似的，如果要用坐標和半徑表示一個圓，也可以用namedtuple定義：

namedtuple('名稱', [屬性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque

使用list存儲數據時，按索引訪問元素很快，但是插入和刪除元素就很慢了，因為list是線性存儲，數據量大的時候，插入和刪除效率很低。

deque是為了高效實現插入和刪除操作的雙向列表，適合用於隊列和棧：

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

deque除了實現list的append()和pop()外，還支持appendleft()和popleft()，這樣就可以非常高效地往頭部添加或刪除元素。

OrderedDict

使用dict時，Key是無序的。在對dict做迭代時，我們無法確定Key的順序。

如果要保持Key的順序，可以用OrderedDict：

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是無序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key會按照插入的順序排列，不是Key本身排序：

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的順序返回
['z', 'y', 'x']

defaultdict

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，將所有大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。

即： {'k1': 大於66 , 'k2': 小於66}

li = [11,22,33,44,55,77,88,99,90]
result = {}
for row in li:
    if row > 66:
        if 'key1' not in result:
            result['key1'] = []
        result['key1'].append(row)
    else:
        if 'key2' not in result:
            result['key2'] = []
        result['key2'].append(row)
print(result)
from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

使用dict時，如果引用的Key不存在，就會拋出KeyError。如果希望key不存在時，返回一個默認值，就可以用defaultdict：

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默認值
'N/A'

Counter

Counter類的目的是用來跟蹤值出現的次數。它是一個無序的容器類型，以字典的鍵值對形式存儲，其中元素作為key，其計數作為value。計數值可以是任意的Interger（包括0和負數）。Counter類和其他語言的bags或multisets很相似。

c = Counter('abcdeabcdabcaba')
print c
輸出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})