Python 簡明教程 --- 12，Python 字典

微信公衆號：碼農充電站pro
我的主頁：https://codeshellme.github.io

代碼寫的越急，程序跑得越慢。
—— Roy Carlson

目錄

Python 字典是另外一種很是實用的數據結構，在Python 中用dict 表示，是英文dictionary 的縮寫。

>>> dict
<class 'dict'>

Python 中的dict 在其它編程語言中通常用map 表示，雖然叫法不一樣，但基本原來是相通的。

1，Python 字典

Python 字典中的數據，以鍵值對(key:value)的形式存儲，字典存儲的是一個一一對應 的映射關係。

Python 中的字典類型，有以下特色：

• 字典中的鍵 是惟一的，不重複的
• 字典中的鍵 能夠是任意一種不可變類型，好比字符串，數字，元組
• 字典中的值能夠是任意一種數據類型
• 字典中的數據能夠動態的刪除/增長/修改
• Python 會在須要的時候自動的擴容和縮容，方便開發者使用

2，聲明字典

Python 中的字典使用大括號{} 表示，字典中的值以key:value 的形式存儲，注意key，value 之間有個冒號:。

示例：

>>> d = {}  # 一個空字典

字典中的鍵 能夠是任意一種不可變類型，值能夠是任意類型：

>>> d = {'name':'jack', 'age':18, 'flag':True}

提示：

雖然字典中的鍵能夠是任意的不可變類型數據，但大部分狀況下，咱們只會使用字符串 類型

字典中的鍵不能是列表這樣的可變類型的數據：

>>> l = [1, 2, 3]
>>> d = {l:'123'}  # 出現異常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

3，字典元素個數

字典中元素的個數，就是字典中鍵的個數，能夠用len() 查看：

>>> d = {'name':'jack', 'age':18, 'flag':True}  
>>> len(d)
3

4，訪問字典數據

使用索引訪問某個元素

咱們能夠用變量名[鍵] 的格式來訪問字典中的數據，在這裏，鍵被稱爲索引。

>>> d = {'name':'jack', 'age':18, 'flag':True} 
>>> d['name']
'jack'
>>> d['age']
18
>>> d['scores']  # 訪問一個不存在的鍵，會拋異常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'scores'

使用for 循環遍歷字典

除了使用索引 訪問字典，還可使用for 循環遍歷字典：

>>> d = {'name':'jack', 'age':18, 'flag':True} 
>>> for key in d: # key 是 d 的鍵，d[key] 是對應的值
...     print('key:%s value:%s' % (key, d[key]))
... 
key:name value:jack
key:age value:18
key:flag value:True

上面的方式，是經過遍歷字典中的鍵key，再經過索引的方式訪問值d[key]。

5，修改字典

字典的修改操做包括添加元素，修改元素和刪除元素。

添加和修改元素

使用索引和賦值語句能夠向字典中添加和修改元素：

• 當給字典中一個已存在的鍵，再次賦值，就是修改元素
• 當給字典中一個不已存在的鍵，去賦值，就是添加元素

示例：

>>> d = {'a':1}		# 初始化一個字典
>>> d['b'] = 2		# 給一個不存在的鍵去賦值，會添加元素
>>> d               # 字典中多了鍵值對 'b':2
{'a': 1, 'b': 2}
>>> d['a'] = 3      # 給一個已存在的鍵去賦值，會修改這個鍵的值
>>> d               # 鍵'a' 的值從原來的 1，變爲了 3
{'a': 3, 'b': 2}

刪除元素

使用索引和del 關鍵字能夠刪除字典中的鍵值對：

>>> d = {'a': 3, 'b': 2}
>>> del d['a']
>>> d
{'b': 2}

6，字典包含

可使用 in 和not in 運算符，查看一個鍵是否存在和不存在於一個字典中：

>>> d = {'a':1, 'b':2}
>>> 'a' in d
True
>>> 'a' not in d
False

7，字典函數

可經過dir(dict) 或 dir(字典對象) 來查看Python 字典支持的方法：

>>> dir(dict)
['__class__', '__contains__', 
'__delattr__', '__delitem__', 
'__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', 
'__getattribute__', '__getitem__', 
'__gt__', '__hash__', '__init__', 
'__init_subclass__', '__iter__', 
'__le__', '__len__', '__lt__', 
'__ne__', '__new__', '__reduce__', 
'__reduce_ex__', '__repr__', 
'__setattr__', '__setitem__', 
'__sizeof__', '__str__', 
'__subclasshook__', 
'clear', 'copy', 'fromkeys', 'get', 
'items', 'keys', 'pop', 'popitem', 
'setdefault', 'update', 'values']

這裏咱們依然只關注非魔法方法，共11 個。

1.get 方法

做用：獲取字典D 中的鍵k 的值D[k]
原型：D.get(k[,d]) -> D[k]
參數 k：要獲取的鍵
參數 d：當D 中不存在k 時，返回d，d 可省，默認爲None
返回值：若是k 存在，返回D[k]，不然返回 d

示例：

>>> d = {'a':1}
>>> d.get('a')        # d['a'] 存在
1
>>> b = d.get('b')    # d['b'] 不存在，返回 None
>>> print(b)          # b 爲 None
None
>>> b = d.get('b', 5) # d['b'] 不存在，返回 5
>>> print(b)          # b 爲 5
5

2.update 方法

做用：使用E 和 F 來更新字典D 中的元素
原型：D.update([E, ]**F) -> None
參數：E 爲字典或者其它可迭代類型
返回值：老是返回None

示例：

>>> d1 = {'a':1, 'c':3}
>>> d2 = {'a':5, 'b':7}
>>> d1.update(d2)   # 對於 d2 中的全部的鍵k，執行 d1[k] = d2[k]
>>> d1              
{'a': 5, 'c': 3, 'b': 7}
>>> d1.update(a=8, d=6) # 也能夠是這種形式的參數
>>> d1
{'a': 8, 'c': 3, 'b': 7, 'd': 6}

3.fromkeys 方法

做用：建立一個新的字典，該字典以序列iterable 中的元素做爲鍵，每一個鍵的值都是value
原型：dict.fromkeys(iterable, value=None, /)
參數 iterable：能夠是任意的可迭代類型
參數 value：新字典中的每一個鍵的值都是value，可省，默認爲None
返回值：一個新的字典

示例：

>>> dict.fromkeys({'a':1, 'c':3})  # 參數是字典類型
{'a': None, 'c': None}             # 一個新的字典，每一個鍵的值都是 None
>>> dict.fromkeys({'a':1, 'c':3}, 5)
{'a': 5, 'c': 5}                   # 每一個鍵的值都是 5
>>> dict.fromkeys(['a', 'b'])      # 參數是列表類型
{'a': None, 'b': None}

4.items 方法

做用：將字典D 轉換成一個可遍歷的列表，列表中的元素由D 中的鍵值對組成
原型：D.items() -> dict_items
參數：無
返回值：一個dict_items 類型的可遍歷的列表

示例：

>>> d = {'a':1, 'c':3}
>>> items = d.items() 
>>> items # 將d 中的 key:vale 轉成了 (key, value)
dict_items([('a', 1), ('c', 3)])
>>> type(items)       # 類型爲 dict_items
<class 'dict_items'>

將dict_items 類型理解爲一個可遍歷的列表便可，列表中的元素是元組類型

該方法經常使用於遍歷字典：

>>> d = {'a':1, 'c':3}
>>> for k, v in d.items():
...     print(k, v)
... 
a 1
c 3

5.keys 方法

做用：返回字典D 中全部的鍵
原型：D.keys() -> dict_keys
參數：無
返回值：一個dict_keys 類型的可遍歷的列表

示例：

>>> d = {'a':1, 'c':3}
>>> keys = d.keys()
>>> keys      # 提取了 d 中全部的鍵
dict_keys(['a', 'c'])
>>> type(keys)
<class 'dict_keys'>

將dict_keys 類型理解爲一個可遍歷的列表便可

6.values 方法

做用：返回字典D 中全部的值
原型：D.values() -> dict_values
參數：無
返回值：一個dict_values 類型的可遍歷的列表

示例：

>>> d = {'a':1, 'c':3}
>>> vs = d.values()
>>> vs     # 提取了 d 中全部的鍵
dict_values([1, 3])
>>> type(vs)
<class 'dict_values'>

將dict_values 類型理解爲一個可遍歷的列表便可

7.pop 方法

做用：刪除字典D 中的鍵k，並返回D[k]
原型：D.pop(k[,d]) -> v
參數 k：要刪除的鍵
參數 d：若D[k] 存在，返回D[k]，若D[k] 不存在，則返回d。參數d 可省
返回值：

D[k] 存在時，返回D[k]
D[k] 不存在，參數d 存在時，返回d
D[k] 不存在且參數d 不存在，拋出KeyError 異常

示例，當要pop 的鍵存在時：

>>> d = {'a': 1, 'c': 3}
>>> d.pop('c')     # d['c'] 存在
3                  # 返回 d['c']
>>> d              # 鍵 'c' 被刪除，只剩 'a'
{'a': 1}

示例，當要pop 的鍵存在時：

>>> d.pop('c')     # 鍵 'c' 不存在，拋出異常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'c'
>>> 
>>> d.pop('c', 5)  # 鍵'c' 不存在，但有第二個參數
5                  # 返回第 2 個參數

8.popitem 方法

做用：刪除並返回字典D 中的最後一個鍵值對，順序是先進後出
原型：D.popitem() -> (k, v)
參數：無
返回值：一個元組類型，D 爲空時，拋出異常

關於popitem 的順序：

• 若是聲明字典時，已有元素，按照從左到右的書寫順序，左爲前，右爲後
• 當動態向字典中增長元素時，先加入的爲前，後加入的爲後

示例，聲明字典時，已有元素：

>>> d = {'c':3, 'a':1, 'b':2}
>>> d           # 順序爲 c,a,b
{'c': 3, 'a': 1, 'b': 2}
>>> d.popitem() # pop 出 'b'
('b', 2)
>>> d           # 還剩 c, a
{'c': 3, 'a': 1}
>>> d.popitem() # pop 出 'a'
('a', 1)
>>> d           # 還剩 'c'
{'c': 3}

向字典中添加元素z和x：

>>> d['z'] = 6  # 增長 'z'
>>> d
{'c': 3, 'z': 6}
>>> d['x'] = 8  # 再增長 'x'
>>> d           # 如今的順序爲 c,z,x
{'c': 3, 'z': 6, 'x': 8}

再次執行popitem：

>>> d.popitem() # pop 出 x
('x', 8)
>>> d           # 還剩 c,z
{'c': 3, 'z': 6}
>>> d.popitem() # pop 出 z
('z', 6)
>>> d           # 還剩 c
{'c': 3}
>>> d.popitem() # pop 出 c
('c', 3)
>>> d           # 字典爲空
{}

字典爲空時，執行popitem，拋出異常：

>>> d.popitem() # 拋出異常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'

9.setdefault 方法

做用：設置字典D 中鍵k 的值

當D[k] 存在時：不作任何事情，只返回D[k]
當D[k] 不存在時：執行D[k] = d，並返回d

原型：D.setdefault(k[,d]) -> value
參數 k：要設置的鍵
參數 d：要設置的值，可省，默認爲 None
返回值：返回D[k]

示例，當要設置的鍵存在時：

>>> d = {'a':1}
>>> d.setdefault('a')    # d['a'] 存在，只返回d['a']
1
>>> d                    # d 不改變
{'a': 1}
>>> d.setdefault('a', 5) # d['a'] 存在，只返回d['a']
1
>>> d                    # d 不改變
{'a': 1}

當要設置的鍵不存在時：

>>> i = d.setdefault('b') # d['b'] 不存在，沒有第 2 個參數
>>> d                     # 執行 d['b'] = None
{'a': 1, 'b': None}       # 執行後的結果   
>>> print(i)              # 返回值爲 None
None
>>> d.setdefault('x', 6) # d['x'] 不存在，有第 2 個參數，執行d['x'] = 6
6                        # 返回 d['x']
>>> d                    # d 如今的值
{'a': 1, 'b': None, 'x': 6}

10.clear 方法

做用：清空字典D
原型：D.clear() -> None
參數：無
返回值：老是返回 None

示例：

>>> d = {'a': 1, 'b': None, 'x': 6}
>>> d.clear()
>>> d   # d 爲空
{}

11.copy 方法

做用：淺拷貝字典D
原型：D.copy() -> dict
參數：無
返回值：字典D 的副本

示例：

>>> d = {'a': 1, 'b': None, 'x': 6}
>>> d1 = d.copy()
>>> d1
{'a': 1, 'b': None, 'x': 6}

（完。）

---

推薦閱讀：

Python 簡明教程 --- 7，Python 字符串

Python 簡明教程 --- 8，Python 字符串函數

Python 簡明教程 --- 9，Python 編碼

Python 簡明教程 --- 10，Python 列表

Python 簡明教程 --- 11，Python 元組

---

歡迎關注做者公衆號，獲取更多技術乾貨。