六、 python中的数据类型——字典

字典（dict）

字典是python内置的一种数据类型，使用键-值（key-value）进行存储，查找速度极快。
字典，顾名思义，就是通过关键字查询它的含义。python中的字典与之类似，每个键对应一个值，使用键可以其访问对应的值。
· 字典的特点是使用花括号，键与值之间用冒号隔开，键值对之间用逗号隔开。
· 键不能重复，值可以重复。
· 字典内的元素是无序的

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}

定义方法与之前定义列表和元组的方法极为相似，只是将括号改为了花括号。
我们可以发现，在定义字典c的时候，是'Tom'在前，'Jack'在后，但是打印的时候，却出现了相反的情况，这是因为元素在字典内是无序的。列表和元组都是有序的。
字典使用了与列表和元组不同的实现方式，在性能上要比列表和元组更快，假设我们要查找一个人的年龄。有两个列表，一个列表储存了所有人的姓名，另一个储存了所有人的年龄。我们首先要在姓名的列表中找到其位置，再通过这个位置，找到年龄列表中对应的值。列表越长，查询速度越慢，时间越长。
但是如果使用字典，将姓名与年龄链接起来，直接根据姓名查询年龄，速度就会快很多，无论这个字典多大，都能保证速度极快。
这是因为python中的字典在实现的时候，使用了哈希表，这个东西查找速度极快，在生成字典的过程中，先后顺序不同，因此里面的元素是无序的。

2. 访问元素

在字典中，通过使用键访问其对应的值。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是字典名，在其后加上中括号与键名，即代表了在该字典中，此键对应的值。
如果你访问的键在字典中不存在，就会报错，类似下面的例子

>>> 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'，因此出现了KeyError: 'Tom'。
因此在访问字典内的元素时，有两种方法可以判断键是否在字典中。

1. in
   与前面列表和元组的例子类似，in也适用于字典，不过只能判断键在不在字典内，不能判断值是否在字典内。

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

2. get方法
   字典内置了get方法。dict.get(key, value)，如果字典内存在key，返回key对应的值，如果不存在，返回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}

我们知道，字典中的键是唯一的，因此如果使用该方法对同一个键赋值多次，只会取最后一次赋值的结果。如下面这个例子

>>> 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)
   字典内置了setdefault()方法，如果key存在，返回其对应的值，如果不存在，将key与value组成键值对，加入到字典中，并返回value

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

因为my_dict中存在'Tom'，所以setdefault('Tom', 'd')返回了'Tom'的值，并且不对其进行赋值。
因为my_dict中不存在'Jack'，所以setdefault('Jack' ,19)返回了19，并且将'Jack'的值赋为了19，存入了字典中。

4. 删除元素

删除字典中的键值对，使用dict.pop(key)方法，对应的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}

当要删除的键不存在的时候，也会报错。

5.其他方法

1. 复制一个字典dict.copy()

>>> my_dict1 = {'Juicy': 12, 'Tom': 20}  #定义字典my_dict1
>>> my_dict2 = my_dict1.copy()  #使用copy()进行复制
>>> print(my_dict2)  #打印复制后的新字典
{'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'>

我们可以发现，使用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

不支持索引
所以我们在使用的时候，可以将其转换成为列表

>>> b = list(my_dict.keys())  #在外面加一个list()，对其强制类型转换，赋给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()))  #打印强制类型转换为列表的字典所有的值
[12, 19, 20]

4. 清空字典dict.clear()
   字典提供了一个叫做clear()的方法，用来清除字典内部所有的键值对。

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

5.查看字典内键值对的个数len()
函数len()对字典也适用。

>>> my_dict = {'Jack': 19, 'Juicy': 12, 'Tom': 20}  #定义字典my_dict
>>> print(len(my_dict))  打印my_dict中元素的个数
3

更多关于字典的信息，可以使用help(dict)查看