聲明：師從老男孩太白金星,不對代碼作任何保證,若有問題請自攜兵刃直奔沙河html
2.6.1 字典的初識python
Why:我們目前已經學習到的容器型數據類型只有list，那麼list夠用？他有什麼缺點呢？linux
1. 列表能夠存儲大量的數據類型，可是若是數據量大的話，他的查詢速度比較慢。算法
2. 列表只能按照順序存儲，數據與數據之間關聯性不強。數組
因此針對於上的缺點，說我們須要引入另外一種容器型的數據類型，解決上面的問題，這就須要dict字典。安全
what：數據結構
數據類型能夠按照多種角度進行分類，就跟我們人同樣，人按照地域能夠劃分分爲亞洲人，歐洲人，美洲人等，可是按照膚色又能夠分爲白種人，黃種人，黑種人，等等，數據類型能夠按照不一樣的角度進行分類，先給你們按照可變與不可變的數據類型的分類：ide
不可變（可哈希）的數據類型：int，str，bool，tuple。學習
可變（不可哈希）的數據類型：list，dict，set。優化
字典是Python語言中的映射類型，他是以{}括起來，裏面的內容是以鍵值對的形式儲存的：
Key: 不可變（可哈希）的數據類型.而且鍵是惟一的，不重複的。
Value:任意數據(int，str，bool，tuple，list，dict，set)，包括後面要學的實例對象等。
在Python3.5版本（包括此版本）以前，字典是無序的。
在Python3.6版本以後，字典會按照初建字典時的順序排列(即第一次插入數據的順序排序)。
固然，字典也有缺點：他的缺點就是內存消耗巨大。
字典查詢之因此快的解釋：（瞭解）
字典的查詢速度很是快，簡單解釋一下緣由：字典的鍵值對會存在一個散列表（稀疏數組）這樣的空間中，每個單位稱做一個表元，表元裏面記錄着key：value,若是你想要找到這個key對應的值，先要對這個key進行hash獲取一串數字我們簡稱爲門牌號（非內存地址），而後經過門牌號，肯定表元，對比查詢的key與被鎖定的key是否相同，若是相同，將值返回，若是不一樣，報錯。（這裏只是簡單的說一下過程，其實仍是比較複雜的。），下面我已圖形舉例：
# 此段解釋來源於《流暢的python》.
這一節籠統地描述了 Python 如何用散列表來實現 dict 類型，有些細節只是一筆帶過，像
CPython 裏的一些優化技巧 就沒有提到。可是整體來講描述是準確的。
Python 源碼 dictobject.c 模塊（http://hg.python.org/cpython/file/tip/Objects/dictobject.c）裏有豐富的註釋，另外延伸閱
讀中有對《代碼之美》一書的引用。
爲了簡單起見，這裏先集中討論 dict 的內部結構，而後再延伸到集合上面。
散列表實際上是一個稀疏數組（老是有空白元素的數組稱爲稀疏數組）。在通常的數據結構
教材中，散列表裏的單元一般叫做表元（bucket）。在 dict 的散列表當中，每一個鍵值對
都佔用一個表元，每一個表元都有兩個部分，一個是對鍵的引用，另外一個是對值的引用。因
爲全部表元的大小一致，因此能夠經過偏移量來讀取某個表元。
由於 Python 會設法保證大概還有三分之一的表元是空的，因此在快要達到這個閾值的時
候，原有的散列表會被複制到一個更大的空間裏面。
若是要把一個對象放入散列表，那麼首先要計算這個元素鍵的散列值。Python 中能夠用
hash() 方法來作這件事情，接下來會介紹這一點。
01. 散列值和相等性
內置的 hash() 方法能夠用於全部的內置類型對象。若是是自定義對象調用 hash()
的話，實際上運行的是自定義的 __hash__。若是兩個對象在比較的時候是相等的，
那它們的散列值必須相等，不然散列表就不能正常運行了。例如，若是 1 == 1.0 爲
8
真，那麼 hash(1) == hash(1.0) 也必須爲真，但其實這兩個數字（整型和浮點）
的內部結構是徹底不同的。
爲了讓散列值可以勝任散列表索引這一角色，它們必須在索引空間中儘可能分散開來。
這意味着在最理想的情況下，越是類似但不相等的對象，它們散列值的差異應該越
大。示例 3-16 是一段代碼輸出，這段代碼被用來比較散列值的二進制表達的不一樣。
注意其中 1 和 1.0 的散列值是相同的，而 1.000一、1.0002 和 1.0003 的散列值則很是不
同。
示例 3-16 在32 位的 Python 中，一、1.000一、1.0002 和 1.0003 這幾個數的散列
值的二進制表達對比（上下兩個二進制間不一樣的位被 ! 高亮出來，表格的最右
列顯示了有多少位不相同）
32-bit Python build
00000000000000000000000000000001
!= 0
1.0 00000000000000000000000000000001
------------------------------------------------
1.0 00000000000000000000000000000001
! !!! ! !! ! ! ! ! !! !!! != 16
1.0001 00101110101101010000101011011101
------------------------------------------------
1.0001 00101110101101010000101011011101
!!! !!!! !!!!! !!!!! !! ! != 20
1.0002 01011101011010100001010110111001
------------------------------------------------
1.0002 01011101011010100001010110111001
! ! ! !!! ! ! !! ! ! ! !!!! != 17
1.0003 00001100000111110010000010010110
------------------------------------------------
用來計算示例 3-16 的程序見於附錄 A。儘管程序裏大部分代碼都是用來整理輸出格
式的，考慮到完整性，我仍是把所有的代碼放在示例 A-3 中了。
從 Python 3.3 開始，str、bytes 和 datetime 對象的散列值計算過程當中多
了隨機的「加鹽」這一步。所加鹽值是 Python 進程內的一個常量，可是每次啓動
Python 解釋器都會生成一個不一樣的鹽值。隨機鹽值的加入是爲了防止 DOS 攻擊
而採起的一種安全措施。在 __hash__ 特殊方法的文檔
（https://docs.python.org/3/reference/datamodel.html#object.__hash__) 裏有相關的詳
細信息。
瞭解對象散列值相關的基本概念以後，咱們能夠深刻到散列表工做原理背後的算法
了。
02. 散列表算法
爲了獲取 my_dict[search_key] 背後的值，Python 首先會調用 hash(search_key)來計算 search_key 的散列值，把這個值最低的幾位數字看成偏移量，在散列表裏查找表元（具體取幾位，得看當前散列表的大小）。若找到的表元是空的，則拋出KeyError 異常。若不是空的，則表元裏會有一對 found_key:found_value。這時候 Python 會檢驗 search_key == found_key 是否爲真，若是它們相等的話，就會返回 found_value。若是 search_key 和 found_key 不匹配的話，這種狀況稱爲散列衝突。發生這種狀況是由於，散列表所作的實際上是把隨機的元素映射到只有幾位的數字上，而散列表自己的索引又只依賴於這個數字的一部分。爲了解決散列衝突，算法會在散列值中另外再取幾位，而後用特殊的方法處理一下，把新獲得的數字再看成索引來尋找表元。若此次找到的表元是空的，則一樣拋出 KeyError；若非空，或者鍵匹配，則返回這個值；或者又發現了散列衝突，則重複以上的步驟。圖 3-3 展現了這個算法的示意
圖。圖 3-3：從字典中取值的算法流程圖；給定一個鍵，這個算法要麼返回一個值，要麼拋出 KeyError 異常添加新元素和更新現有鍵值的操做幾乎跟上面同樣。只不過對於前者，在發現空表元的時候會放入一個新元素；對於後者，在找到相對應的表元后，原表裏的值對象會被替換成新值。
另外在插入新值時，Python 可能會按照散列表的擁擠程度來決定是否要從新分配內存爲它擴容。若是增長了散列表的大小，那散列值所佔的位數和用做索引的位數都會隨之增長，這樣作的目的是爲了減小發生散列衝突的機率。表面上看，這個算法彷佛很費事，而實際上就算 dict 裏有數百萬個元素，多數的搜索過程當中並不會有衝突發生，平均下來每次搜索可能會有一到兩次衝突。在正常狀況下，就算是最不走運的鍵所遇到的衝突的次數用一隻手也能數過來。瞭解 dict 的工做原理能讓咱們知道它的所長和所短，以及從它衍生而來的數據類型
詳細解釋
# 此段解釋來源於《流暢的python》. 這一節籠統地描述了 Python 如何用散列表來實現 dict 類型，有些細節只是一筆帶過，像 CPython 裏的一些優化技巧 就沒有提到。可是整體來講描述是準確的。 Python 源碼 dictobject.c 模塊（http://hg.python.org/cpython/file/tip/Objects/dictobject.c）裏有豐富的註釋，另外延伸閱 讀中有對《代碼之美》一書的引用。 爲了簡單起見，這裏先集中討論 dict 的內部結構，而後再延伸到集合上面。 散列表實際上是一個稀疏數組（老是有空白元素的數組稱爲稀疏數組）。在通常的數據結構 教材中，散列表裏的單元一般叫做表元（bucket）。在 dict 的散列表當中，每一個鍵值對 都佔用一個表元，每一個表元都有兩個部分，一個是對鍵的引用，另外一個是對值的引用。因 爲全部表元的大小一致，因此能夠經過偏移量來讀取某個表元。 由於 Python 會設法保證大概還有三分之一的表元是空的，因此在快要達到這個閾值的時 候，原有的散列表會被複制到一個更大的空間裏面。 若是要把一個對象放入散列表，那麼首先要計算這個元素鍵的散列值。Python 中能夠用 hash() 方法來作這件事情，接下來會介紹這一點。 01. 散列值和相等性 內置的 hash() 方法能夠用於全部的內置類型對象。若是是自定義對象調用 hash() 的話，實際上運行的是自定義的 __hash__。若是兩個對象在比較的時候是相等的， 那它們的散列值必須相等，不然散列表就不能正常運行了。例如，若是 1 == 1.0 爲 8 8 真，那麼 hash(1) == hash(1.0) 也必須爲真，但其實這兩個數字（整型和浮點） 的內部結構是徹底不同的。 爲了讓散列值可以勝任散列表索引這一角色，它們必須在索引空間中儘可能分散開來。 這意味着在最理想的情況下，越是類似但不相等的對象，它們散列值的差異應該越 大。示例 3-16 是一段代碼輸出，這段代碼被用來比較散列值的二進制表達的不一樣。 注意其中 1 和 1.0 的散列值是相同的，而 1.000一、1.0002 和 1.0003 的散列值則很是不 同。 示例 3-16 在32 位的 Python 中，一、1.000一、1.0002 和 1.0003 這幾個數的散列 值的二進制表達對比（上下兩個二進制間不一樣的位被 ! 高亮出來，表格的最右 列顯示了有多少位不相同） 32-bit Python build 1 00000000000000000000000000000001 != 0 1.0 00000000000000000000000000000001 ------------------------------------------------ 1.0 00000000000000000000000000000001 ! !!! ! !! ! ! ! ! !! !!! != 16 1.0001 00101110101101010000101011011101 ------------------------------------------------ 1.0001 00101110101101010000101011011101 !!! !!!! !!!!! !!!!! !! ! != 20 1.0002 01011101011010100001010110111001 ------------------------------------------------ 1.0002 01011101011010100001010110111001 ! ! ! !!! ! ! !! ! ! ! !!!! != 17 1.0003 00001100000111110010000010010110 ------------------------------------------------ 用來計算示例 3-16 的程序見於附錄 A。儘管程序裏大部分代碼都是用來整理輸出格 式的，考慮到完整性，我仍是把所有的代碼放在示例 A-3 中了。 從 Python 3.3 開始，str、bytes 和 datetime 對象的散列值計算過程當中多 了隨機的「加鹽」這一步。所加鹽值是 Python 進程內的一個常量，可是每次啓動 Python 解釋器都會生成一個不一樣的鹽值。隨機鹽值的加入是爲了防止 DOS 攻擊 而採起的一種安全措施。在 __hash__ 特殊方法的文檔 （https://docs.python.org/3/reference/datamodel.html#object.__hash__) 裏有相關的詳 細信息。 瞭解對象散列值相關的基本概念以後，咱們能夠深刻到散列表工做原理背後的算法 了。 02. 散列表算法 爲了獲取 my_dict[search_key] 背後的值，Python 首先會調用 hash(search_key)來計算 search_key 的散列值，把這個值最低的幾位數字看成偏移量，在散列表裏查找表元（具體取幾位，得看當前散列表的大小）。若找到的表元是空的，則拋出KeyError 異常。若不是空的，則表元裏會有一對 found_key:found_value。這時候 Python 會檢驗 search_key == found_key 是否爲真，若是它們相等的話，就會返回 found_value。若是 search_key 和 found_key 不匹配的話，這種狀況稱爲散列衝突。發生這種狀況是由於，散列表所作的實際上是把隨機的元素映射到只有幾位的數字上，而散列表自己的索引又只依賴於這個數字的一部分。爲了解決散列衝突，算法會在散列值中另外再取幾位，而後用特殊的方法處理一下，把新獲得的數字再看成索引來尋找表元。若此次找到的表元是空的，則一樣拋出 KeyError；若非空，或者鍵匹配，則返回這個值；或者又發現了散列衝突，則重複以上的步驟。圖 3-3 展現了這個算法的示意 圖。圖 3-3：從字典中取值的算法流程圖；給定一個鍵，這個算法要麼返回一個值，要麼拋出 KeyError 異常添加新元素和更新現有鍵值的操做幾乎跟上面同樣。只不過對於前者，在發現空表元的時候會放入一個新元素；對於後者，在找到相對應的表元后，原表裏的值對象會被替換成新值。 另外在插入新值時，Python 可能會按照散列表的擁擠程度來決定是否要從新分配內存爲它擴容。若是增長了散列表的大小，那散列值所佔的位數和用做索引的位數都會隨之增長，這樣作的目的是爲了減小發生散列衝突的機率。表面上看，這個算法彷佛很費事，而實際上就算 dict 裏有數百萬個元素，多數的搜索過程當中並不會有衝突發生，平均下來每次搜索可能會有一到兩次衝突。在正常狀況下，就算是最不走運的鍵所遇到的衝突的次數用一隻手也能數過來。瞭解 dict 的工做原理能讓咱們知道它的所長和所短，以及從它衍生而來的數據類型
因爲字典使用了散列表，而散列表又必須是稀疏的，這致使它在空間上的效率低下。舉例而言，若是你須要存放數量巨大的記錄，那麼放在由元組或是具名元組構成的列表中會是比較好的選擇；最好不要根據 JSON 的風格，用由字典組成的列表來存放這些記錄。用元組取代字典就能節省空間的緣由有兩個：其一是避免了散列表所耗費的空間，其二是無需把記錄中字段的名字在每一個元素裏都存一遍。記住咱們如今討論的是空間優化。若是你手頭有幾百萬個對象，而你的機器有幾個GB 的內存，那麼空間的優化工做能夠等到真正須要的時候再開始計劃，由於優化每每是可維護性的對立面。
因爲字典使用了散列表，而散列表又必須是稀疏的，這致使它在空間上的效率低下。舉例而言，若是你須要存放數量巨大的記錄，那麼放在由元組或是具名元組構成的列表中會是比較好的選擇；最好不要根據 JSON 的風格，用由字典組成的列表來存放這些記錄。用元組取代字典就能節省空間的緣由有兩個：其一是避免了散列表所耗費的空間，其二是無需把記錄中字段的名字在每一個元素裏都存一遍。記住咱們如今討論的是空間優化。若是你手頭有幾百萬個對象，而你的機器有幾個GB 的內存，那麼空間的優化工做能夠等到真正須要的時候再開始計劃，由於優化每每是可維護性的對立面。
2.6.2 建立字典的幾種方式：
# 建立字典的幾種方式：
# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式5: 後面會講到先了解
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)
# 方式6: 字典推導式 後面會講到
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)
# 方式7:利用fromkey後面會講到。
# dic = dict.fromkeys('abcd','太白')
# print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
# 建立字典的幾種方式：
# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式5: 後面會講到先了解
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)
# 方式6: 字典推導式 後面會講到
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)
# 方式7:利用fromkey後面會講到。
# dic = dict.fromkeys('abcd','太白')
# print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
2.6.3 驗證字典的合法性
# 合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帥
哥', '美⼥'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])
# 不合法
# dic = {[1, 2, 3]: '周杰倫'} # list是可變的. 不能做爲key
# dic = {{1: 2}: "哈哈哈"} # dict是可變的. 不能做爲key
dic = {{1, 2, 3}: '呵呵呵'} # set是可變的, 不能做爲key
# 合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帥
哥', '美⼥'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])
# 不合法
# dic = {[1, 2, 3]: '周杰倫'} # list是可變的. 不能做爲key
# dic = {{1: 2}: "哈哈哈"} # dict是可變的. 不能做爲key
dic = {{1, 2, 3}: '呵呵呵'} # set是可變的, 不能做爲key
2.6.4 字典的經常使用操做方法
接下來我們就進入字典的學習環節，字典對於我們小白來講可能相對於列表是很差理解的，由於列表是有序的一個一個排列的，可是字典的鍵值對對於你們來講是比較陌生的，因此我們能夠把字典比喻成一個公寓，公寓裏面有N多個房間，房間號就是鍵，房間裏面具體的東西就值：好比房間001號：對應的房間住着兩我的，也就是2person，簡稱2P，房間99號：3P， 房間78號：有人還有小動物....... 這樣，我們就能經過房間號（也就是鍵）找到對應的房間，查看裏面的內容，也就是值。
那麼首先先從字典的增刪改查開始學習。
增
# 經過鍵值對直接增長
dic = {'name': '太白', 'age': 18}
dic['weight'] = 75 # 沒有weight這個鍵，就增長鍵值對
print(dic) # {'name': '太白', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name這個鍵，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}
# setdefault
dic = {'name': '太白', 'age': 18}
dic.setdefault('height',175) # 沒有height此鍵，則添加
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
dic.setdefault('name','barry') # 有此鍵則不變
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
#它有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.setdefault('name')
print(ret) # 太白
字典的增
# 經過鍵值對直接增長
dic = {'name': '太白', 'age': 18}
dic['weight'] = 75 # 沒有weight這個鍵，就增長鍵值對
print(dic) # {'name': '太白', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name這個鍵，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}
# setdefault
dic = {'name': '太白', 'age': 18}
dic.setdefault('height',175) # 沒有height此鍵，則添加
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
dic.setdefault('name','barry') # 有此鍵則不變
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
#它有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.setdefault('name')
print(ret) # 太白
刪
# pop 經過key刪除字典的鍵值對，有返回值，可設置返回值。
dic = {'name': '太白', 'age': 18}
# ret = dic.pop('name')
# print(ret,dic) # 太白 {'age': 18}
ret1 = dic.pop('n',None)
print(ret1,dic) # None {'name': '太白', 'age': 18}
#popitem 3.5版本以前，popitem爲隨機刪除，3.6以後爲刪除最後一個，有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.popitem()
print(ret,dic) # ('age', 18) {'name': '太白'}
#clear 清空字典
dic = {'name': '太白', 'age': 18}
dic.clear()
print(dic) # {}
# del
# 經過鍵刪除鍵值對
dic = {'name': '太白', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
#刪除整個字典
del dic
字典的刪
# pop 經過key刪除字典的鍵值對，有返回值，可設置返回值。
dic = {'name': '太白', 'age': 18}
# ret = dic.pop('name')
# print(ret,dic) # 太白 {'age': 18}
ret1 = dic.pop('n',None)
print(ret1,dic) # None {'name': '太白', 'age': 18}
#popitem 3.5版本以前，popitem爲隨機刪除，3.6以後爲刪除最後一個，有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.popitem()
print(ret,dic) # ('age', 18) {'name': '太白'}
#clear 清空字典
dic = {'name': '太白', 'age': 18}
dic.clear()
print(dic) # {}
# del
# 經過鍵刪除鍵值對
dic = {'name': '太白', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
#刪除整個字典
del dic
改
# 經過鍵值對直接改
dic = {'name': '太白', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}
# update
dic = {'name': '太白', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}
dic = {'name': '太白', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}
字典的改
# 經過鍵值對直接改
dic = {'name': '太白', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}
# update
dic = {'name': '太白', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}
dic = {'name': '太白', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}
查
# 經過鍵查詢
# 直接dic[key](沒有此鍵會報錯)
dic = {'name': '太白', 'age': 18}
print(dic['name']) # 太白
# get
dic = {'name': '太白', 'age': 18}
v = dic.get('name')
print(v) # '太白'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','沒有此鍵')
print(v) # 沒有此鍵
keys()
dic = {'name': '太白', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age'])
values()
dic = {'name': '太白', 'age': 18}
print(dic.values()) # dict_values(['太白', 18])
items()
dic = {'name': '太白', 'age': 18}
print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])
字典的查
# 經過鍵查詢
# 直接dic[key](沒有此鍵會報錯)
dic = {'name': '太白', 'age': 18}
print(dic['name']) # 太白
# get
dic = {'name': '太白', 'age': 18}
v = dic.get('name')
print(v) # '太白'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','沒有此鍵')
print(v) # 沒有此鍵
keys()
dic = {'name': '太白', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age'])
values()
dic = {'name': '太白', 'age': 18}
print(dic.values()) # dict_values(['太白', 18])
items()
dic = {'name': '太白', 'age': 18}
print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
請在字典中添加一個鍵值對，"k4": "v4"，輸出添加後的字典
請在修改字典中 "k1" 對應的值爲 "alex"，輸出修改後的字典
請在k3對應的值中追加一個元素 44，輸出修改後的字典
請在k3對應的值的第 1 個位置插入個元素 18，輸出修改後的字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
請在字典中添加一個鍵值對，"k4": "v4"，輸出添加後的字典
請在修改字典中 "k1" 對應的值爲 "alex"，輸出修改後的字典
請在k3對應的值中追加一個元素 44，輸出修改後的字典
請在k3對應的值的第 1 個位置插入個元素 18，輸出修改後的字典
fromkeys 數據類型的補充時會給你們講到~
dic = dict.fromkeys('abcd','太白')
print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
dic = dict.fromkeys([1, 2, 3],'太白')
print(dic) # {1: '太白', 2: '太白', 3: '太白'}
dic = dict.fromkeys('abcd','太白')
print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
dic = dict.fromkeys([1, 2, 3],'太白')
print(dic) # {1: '太白', 2: '太白', 3: '太白'}
其餘操做
key_list = dic.keys()
print(key_list)
結果:
dict_keys(['劍聖', '哈啥給', '大寶劍'])
# 一個高仿列表,存放的都是字典中的key
# 而且這個高仿的列表能夠轉化成列表
print(list(key_list))
# 它還能夠循環打印
dic = {'劍聖':'易','哈啥給':'劍豪','大寶劍':'蓋倫'}
for i in dic:
print(i)
value_list = dic.values()
print(value_list)
結果:
dict_values(['易', '劍豪', '蓋倫'])
#一個高仿列表,存放都是字典中的value
# 而且這個高仿的列表能夠轉化成列表
print(list(value_list))
# 它還能夠循環打印
for i in dic.values():
print(i)
key_value_list = dic.items()
print(key_value_list)
結果:
dict_items([('劍聖', '易'), ('哈啥給', '劍豪'), ('大寶劍', '蓋倫')])
# 一個高仿列表,存放是多個元祖,元祖中第一個是字典中的鍵,第二個是字典中的值
# 而且這個高仿的列表能夠轉化成列表
print(list(key_value_list ))
# 它還能夠循環打印
dic = {'劍聖':'易','哈啥給':'劍豪','大寶劍':'蓋倫'}
for i in dic.items():
print(i)
結果：
('劍聖', '易')
('哈啥給', '劍豪')
('大寶劍', '蓋倫')
key_list = dic.keys()
print(key_list)
結果:
dict_keys(['劍聖', '哈啥給', '大寶劍'])
# 一個高仿列表,存放的都是字典中的key
# 而且這個高仿的列表能夠轉化成列表
print(list(key_list))
# 它還能夠循環打印
dic = {'劍聖':'易','哈啥給':'劍豪','大寶劍':'蓋倫'}
for i in dic:
print(i)
value_list = dic.values()
print(value_list)
結果:
dict_values(['易', '劍豪', '蓋倫'])
#一個高仿列表,存放都是字典中的value
# 而且這個高仿的列表能夠轉化成列表
print(list(value_list))
# 它還能夠循環打印
for i in dic.values():
print(i)
key_value_list = dic.items()
print(key_value_list)
結果:
dict_items([('劍聖', '易'), ('哈啥給', '劍豪'), ('大寶劍', '蓋倫')])
# 一個高仿列表,存放是多個元祖,元祖中第一個是字典中的鍵,第二個是字典中的值
# 而且這個高仿的列表能夠轉化成列表
print(list(key_value_list ))
# 它還能夠循環打印
dic = {'劍聖':'易','哈啥給':'劍豪','大寶劍':'蓋倫'}
for i in dic.items():
print(i)
結果：
('劍聖', '易')
('哈啥給', '劍豪')
('大寶劍', '蓋倫')
這裏補充一個知識點：分別賦值，也叫拆包。
a,b = 1,2
print(a,b)
結果:
2
a,b = ('你好','世界') # 這個用專業名詞就叫作元組的拆包
print(a,b)
結果:
你好 世界
a,b = ['你好','大飛哥']
print(a,b)
結果:
你好 世界
a,b = {'汪峯':'北京北京','王菲':'天后'}
print(a,b)
結果:
汪峯 王菲
a,b = 1,2
print(a,b)
結果:
1 2
a,b = ('你好','世界') # 這個用專業名詞就叫作元組的拆包
print(a,b)
結果:
你好 世界
a,b = ['你好','大飛哥']
print(a,b)
結果:
你好 世界
a,b = {'汪峯':'北京北京','王菲':'天后'}
print(a,b)
結果:
汪峯 王菲
因此利用上面剛學的拆包的概念，咱們循環字典時還能夠這樣獲取字典的鍵，以及值：
for k,v in dic.items():
print('這是鍵',k)
print('這是值',v)
結果:
這是鍵 劍聖
這是值 易
這是鍵 哈啥給
這是值 劍豪
這是鍵 大寶劍
這是值 蓋倫
for k,v in dic.items():
print('這是鍵',k)
print('這是值',v)
結果:
這是鍵 劍聖
這是值 易
這是鍵 哈啥給
這是值 劍豪
這是鍵 大寶劍
這是值 蓋倫
4.1.5字典的嵌套
字典的嵌套是很是重要的知識點，這個必需要創建在熟練使用字典的增刪改查的基礎上，並且字典的嵌套纔是我們在工做中常常會遇到的字典，工做中遇到的字典不是簡簡單單一層，而就像是蔥頭同樣，一層接一層，但通常都是頗有規律的嵌套，那麼接下來咱們就學習一下字典的嵌套：
如今有以下字典，完成一下需求：
dic = {
'name':'汪峯',
'age':48,
'wife':[{'name':'國際章','age':38}],
'children':{'girl_first':'小蘋果','girl_second':'小怡','girl_three':'頂頂'}
}
1. 獲取汪峯的名字。
2.獲取這個字典：{'name':'國際章','age':38}。
3. 獲取汪峯妻子的名字。
4. 獲取汪峯的第三個孩子名字。
dic = {
'name':'汪峯',
'age':48,
'wife':[{'name':'國際章','age':38}],
'children':{'girl_first':'小蘋果','girl_second':'小怡','girl_three':'頂頂'}
}
1. 獲取汪峯的名字。
2.獲取這個字典：{'name':'國際章','age':38}。
3. 獲取汪峯妻子的名字。
4. 獲取汪峯的第三個孩子名字。
解題思路：
1.獲取汪峯的名字。: 這個比較簡單，汪峯就是dic的一個鍵對應的值，咱們經過這個key就能夠獲取到汪峯這個值。
name = dic['name'] print(name)
name = dic['name'] print(name)
2. 獲取這個字典{'name':'國際章','age':38}: 想要獲取這個字典，先要看字典從屬於誰？這個字典從屬於一個列表，而這個列表是字典wife對應的鍵，因此我們應該先經過wife獲取到對應的這個列表，而後經過這個列表按照因此取值取到對應的這個字典。
l1 = dic['wife'] # 先獲取到這個列表
di = l1[0] # 列表按照索引取值，這個字典是列表的第一個元素，因此經過索引獲取到這個字典
print(di)
# 固然上面是分佈獲取的，咱們還能夠合併去寫：
di = dic['wife'][0]
print(di)
l1 = dic['wife'] # 先獲取到這個列表 di = l1[0] # 列表按照索引取值，這個字典是列表的第一個元素，因此經過索引獲取到這個字典 print(di) # 固然上面是分佈獲取的，咱們還能夠合併去寫： di = dic['wife'][0] print(di)
3. 獲取汪峯的妻子名字: 仍是按照上一題的思路：想要獲取汪峯妻子的名字：國際章，那麼他是一個字典的鍵對應的值，因此咱們經過'name'這個鍵就能夠獲取到對應的值，這個題的難點是獲取到這個小字典，而上一個題咱們已經獲取了這個小字典，因此在上面的基礎上再執行就能夠了。
di = dic['wife'][0] # 這個是上一次題獲取的小字典的代碼
wife_name= di['name'] # 經過小字典而後再經過鍵就能獲取到對應的值
print(wife_name)
# 固然我們能夠簡化：
wife_name = dic['wife'][0]['name]
print(wife_name)
di = dic['wife'][0] # 這個是上一次題獲取的小字典的代碼 wife_name= di['name'] # 經過小字典而後再經過鍵就能獲取到對應的值 print(wife_name) # 固然我們能夠簡化： wife_name = dic['wife'][0]['name] print(wife_name)
4. 獲取汪峯的第三個孩子名字: 汪峯的孩子們是在一個字典中的，你要想獲取汪峯的第三個孩子，你應該先獲取到它從屬於的這個字典，而後再經過這個字典獲取第三個孩子的名字。
dic2 = dic['children'] # 先獲取這個字典
name = dic2['girl_three'] # 在經過這個字典獲取第三個孩子的名字
print(name)
# 固然你能夠簡化：
name = dic['children']['girl_three']
print(name)
dic2 = dic['children'] # 先獲取這個字典 name = dic2['girl_three'] # 在經過這個字典獲取第三個孩子的名字 print(name) # 固然你能夠簡化： name = dic['children']['girl_three'] print(name)
dic1 = {
'name':['alex',2,3,5],
'job':'teacher',
'oldboy':{'alex':['python1','python2',100]}
}
1，將name對應的列表追加⼀個元素’wusir’。
2，將name對應的列表中的alex⾸字⺟⼤寫。
3，oldboy對應的字典加⼀個鍵值對’⽼男孩’,’linux’。
4，將oldboy對應的字典中的alex對應的列表中的python2刪除
相關練習題
dic1 = {
'name':['alex',2,3,5],
'job':'teacher',
'oldboy':{'alex':['python1','python2',100]}
}
1，將name對應的列表追加⼀個元素’wusir’。
2，將name對應的列表中的alex⾸字⺟⼤寫。
3，oldboy對應的字典加⼀個鍵值對’⽼男孩’,’linux’。
4，將oldboy對應的字典中的alex對應的列表中的python2刪除