字典（dict）

字典是python內(nèi)置的一種數(shù)據(jù)類型，使用鍵-值（key-value）進(jìn)行存儲，查找速度極快。
字典，顧名思義，就是通過關(guān)鍵字查詢它的含義。python中的字典與之類似，每個鍵對應(yīng)一個值，使用鍵可以其訪問對應(yīng)的值。
· 字典的特點是使用花括號，鍵與值之間用冒號隔開，鍵值對之間用逗號隔開。
· 鍵不能重復(fù)，值可以重復(fù)。
· 字典內(nèi)的元素是無序的

1. 定義字典

>>> a = {}  #定義一個空字典
>>> print(type(a))  #打印a的類型
<class 'dict'>  #a的類型是字典
>>> b = {'Tom': 20}  #定義一個只含有一個鍵值對的字典
>>> c = {'Tom': 20, 'Jack': 19}  #定義一個含有兩個鍵值對的字典
>>> print(b)  #打印b
{'Tom': 20}
>>> print(c)  #打印c
{'Jack': 19, 'Tom': 20}

定義方法與之前定義列表和元組的方法極為相似，只是將括號改為了花括號。
我們可以發(fā)現(xiàn)，在定義字典c的時候，是'Tom'在前，'Jack'在后，但是打印的時候，卻出現(xiàn)了相反的情況，這是因為元素在字典內(nèi)是無序的。列表和元組都是有序的。
字典使用了與列表和元組不同的實現(xiàn)方式，在性能上要比列表和元組更快，假設(shè)我們要查找一個人的年齡。有兩個列表，一個列表儲存了所有人的姓名，另一個儲存了所有人的年齡。我們首先要在姓名的列表中找到其位置，再通過這個位置，找到年齡列表中對應(yīng)的值。列表越長，查詢速度越慢，時間越長。
但是如果使用字典，將姓名與年齡鏈接起來，直接根據(jù)姓名查詢年齡，速度就會快很多，無論這個字典多大，都能保證速度極快。
這是因為python中的字典在實現(xiàn)的時候，使用了哈希表，這個東西查找速度極快，在生成字典的過程中，先后順序不同，因此里面的元素是無序的。

2. 訪問元素

在字典中，通過使用鍵訪問其對應(yīng)的值。dict[key]

>>> name_age = {'Tom': 20, 'Jack': 19}  #定義字典name_age
>>> print(name_age['Tom'])  #打印字典name_age中'Tom'的值
20
>>> print(name_age['Jack'])  #打印字典name_age中'Jack'的值
19

在列表和元組中訪問元素是通過索引的方式，在字典中是通過使用鍵訪問，兩者的相同之處都是使用“對象+中括號”，在上例中，name_age是字典名，在其后加上中括號與鍵名，即代表了在該字典中，此鍵對應(yīng)的值。
如果你訪問的鍵在字典中不存在，就會報錯，類似下面的例子

>>> a = {}  #定義字典a
>>> print(a['Tom'])  #打印字典a中的'Tom'的值
Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    print(a['Tom'])
KeyError: 'Tom'

我們要訪問a中'Tom'的值，但是a中并不存在'Tom'，因此出現(xiàn)了KeyError: 'Tom'。
因此在訪問字典內(nèi)的元素時，有兩種方法可以判斷鍵是否在字典中。

1. in
   與前面列表和元組的例子類似，in也適用于字典，不過只能判斷鍵在不在字典內(nèi)，不能判斷值是否在字典內(nèi)。

>>> a = {'Jack': 20, 'Tom': 19}  #定義字典
>>> print('Jack' in a)
True  #'Jack' in a為真
>>> print('David' in a)
False  #'David' in a為假

2. get方法
   字典內(nèi)置了get方法。dict.get(key, value)，如果字典內(nèi)存在key，返回key對應(yīng)的值，如果不存在，返回value，沒有指定value的時候，返回None

>>> a = {'Jack': 20, 'Tom': 19}
>>> print(a.get('Jack'))
20
>>> print(a.get('David'))
None
>>> print(a.get('David',2))
2
>>> print(a)
{'Jack': 20, 'Tom': 19}

3.添加元素

1. 在字典中添加元素可以使用鍵加入。dict[key] = value

>>> a = {}  #定義一個空字典
>>> a['Tom'] = 19  #加入'Tom'，賦值為19
>>> a['Jack'] = 20  #加入'Jack'，賦值為20
>>> print(a)  #打印字典a
{'Jack': 20, 'Tom': 19}

我們知道，字典中的鍵是唯一的，因此如果使用該方法對同一個鍵賦值多次，只會取最后一次賦值的結(jié)果。如下面這個例子

>>> a = {'Jack': 20, 'Tom': 19}  #定義字典
>>> a['David'] = 20  #在字典中加入'David'并賦值為20
>>> print(a['David'])  #打印字典中'David'的值
20
>>> a['David'] = 21  #將字典中的'David'賦值為21
>>> print(a['David'])  #打印字典中'David'的值
21
>>> print(a)  #打印字典a
{'David': 21, 'Jack': 20, 'Tom': 19}

2. dict.setdefault(key,value)
   字典內(nèi)置了setdefault()方法，如果key存在，返回其對應(yīng)的值，如果不存在，將key與value組成鍵值對，加入到字典中，并返回value

>>> my_dict = {'Juicy': 12, 'Tom': 20}  #定義字典
>>> my_dict.setdefault('Tom', 'd')  #使用setdefault設(shè)置'Tom'的值
20
>>> my_dict.setdefault('Jack', 19)  #使用setdefault設(shè)置'Jack'的值
19
>>> print(my_dict)
{'Juicy': 12, 'Jack': 19, 'Tom': 20}

因為my_dict中存在'Tom'，所以setdefault('Tom', 'd')返回了'Tom'的值，并且不對其進(jìn)行賦值。
因為my_dict中不存在'Jack'，所以setdefault('Jack' ,19)返回了19，并且將'Jack'的值賦為了19，存入了字典中。

4. 刪除元素

刪除字典中的鍵值對，使用dict.pop(key)方法，對應(yīng)的value也會一并刪除。

>>> my_dict = {'Juicy': 12, 'Tom': 20}  #定義字典
>>> my_dict.pop('Tom')  #刪除my_dict中'Tom'及其值
20
>>> my_dict.pop('David')  #刪除my_dict中'David'及其值
Traceback (most recent call last):
  File "<pyshell#46>", line 1, in <module>
    my_dict.pop('David')
KeyError: 'David'  #報錯，因為字典中不存在'David'這個鍵
>>> print(my_dict)  #打印字典
{'Juicy': 12}

當(dāng)要刪除的鍵不存在的時候，也會報錯。

5.其他方法

1. 復(fù)制一個字典dict.copy()

>>> my_dict1 = {'Juicy': 12, 'Tom': 20}  #定義字典my_dict1
>>> my_dict2 = my_dict1.copy()  #使用copy()進(jìn)行復(fù)制
>>> print(my_dict2)  #打印復(fù)制后的新字典
{'Juicy': 12, 'Tom': 20}

2. 查看所有的鍵dict.keys()

>>> my_dict = {'Jack': 19, 'Juicy': 12, 'Tom': 20}  #定義字典
>>> print(my_dict.keys())  #打印my_dict中所有的鍵
dict_keys(['Tom', 'Juicy', 'Jack'])
>>> print(type(my_dict.keys()))  #打印其類型
<class 'dict_keys'>

我們可以發(fā)現(xiàn)，使用dict.keys()即可得到dict這個字典中所有的鍵，得到的類型，就是上面寫的'dict_keys'，這種類型比較奇葩，不能靈活的操作，像索引一類的都不能使用。

>>> my_dict.keys()[0]
Traceback (most recent call last):
  File "<pyshell#53>", line 1, in <module>
    my_dict.keys()[0]
TypeError: 'dict_keys' object does not support indexing

不支持索引
所以我們在使用的時候，可以將其轉(zhuǎn)換成為列表

>>> b = list(my_dict.keys())  #在外面加一個list()，對其強制類型轉(zhuǎn)換，賦給b
>>> print(b)  #打印b
['Tom', 'Juicy', 'Jack']

就可以得到所有的鍵組成的一個列表了，這樣就方便操作了。

3. 查看所有的值dict.values()
   與dict.keys()類似

>>> my_dict = {'Jack': 19, 'Juicy': 12, 'Tom': 20}  #定義字典
>>> print(my_dict.values())  #打印字典所有的值
dict_values([20, 12, 19])
print(list(my_dict.values()))  #打印強制類型轉(zhuǎn)換為列表的字典所有的值
[12, 19, 20]

4. 清空字典dict.clear()
   字典提供了一個叫做clear()的方法，用來清除字典內(nèi)部所有的鍵值對。

>>> my_dict = {'Jack': 19, 'Juicy': 12, 'Tom': 20}  #定義字典
>>> my_dict.clear()  #清除my_dict內(nèi)所有元素
>>> print(my_dict)  #打印字典
{}

5.查看字典內(nèi)鍵值對的個數(shù)len()
函數(shù)len()對字典也適用。

>>> my_dict = {'Jack': 19, 'Juicy': 12, 'Tom': 20}  #定義字典my_dict
>>> print(len(my_dict))  打印my_dict中元素的個數(shù)
3

更多關(guān)于字典的信息，可以使用help(dict)查看