11. 数据类型 - 字典


Hi，大家好。我是茶桁。

关于Python的数据类型，我们已经详细讲解了三种，字符串，列表和元组。那么今天，我们再来讲一种：字典。

字典也是一种数据的集合，由健值对组成的数据集合，字典中的键是不能重复的。

字典中的键必须是不可变的数据类型，常用的键主要是：字符串，整型...

实际上，在之前字符串和列表的铺垫之后，任何数据类型其实都会感觉差不多，当然，每个数据类型也都有自己的特点以及需要注意的地方，不过在方法，操作上也会有很多类同点。

那么，让我们开始学习字典吧。

字典的定义

字典可以通过把以逗号分隔的对列表包含于花括号之内来创建字典。

也可以通过构造器来创建

或者

让我们开始写代码来做实验：

使用定义:

myDict = {'a':1, 'b':2, 'c':2}

print(myDict)

---

{'a': 1, 'b': 2, 'c': 2}

使用函数进行定义

myDict = dict(name='张三', sex='male', age=22)

print(myDict)

---

{'name': '张三', 'sex': 'male', 'age': 22}

数据类型的转换： 列表或元组，并且只有二级容器才可以转换

myDict = dict([['a',1], ['b',2], ['c',3]])

print(myDict)

---

{'a': 1, 'b': 2, 'c': 3}

让我们来试试如果不是二级容器类型会如何：

myDict = dict(['a',1], ['b',2], ['c',3])

print(myDict)

---

TypeError: dict expected at most 1 argument, got 3

报错了，提示我们字典最多一个参数，但是现在里面有3个。

再继续试试其他情况：

myDict = dict([[['a',1],['b',2],['c',3]]])

print(myDict)

---

ValueError: dictionary update sequence element #0 has length 3; 2 is required

再次抛出异常，提示字典更新序列元素长度为3，第2位是必填项。

以上可以看出，只有二级容器才能通过函数来做数据类型的转换。

压缩函数，转类型

ex1 = [1, 2, 3, 4]

ex2 = ['a', 'b', 'c', 'd']

# 压缩过后做的事情其实就是数据类型的转换

myDict = dict(zip(ex1, ex2))

print(myDict)

---

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

字典的操作

还记得吗，无论是列表还是元组，都支持数学的基本运算符和。那字典是不是也同样支持？

ex1 = {'a':1, 'b':2, 'c':3}

ex2 = {1:'a', 2:'b', 3:'c', 4:'d'}

print(ex1 + ex2)

---

TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

提示类型错误，实际上也是一样，这里我们就不占用篇幅再多打印一次错误了。说明，字典并不支持这两个基本的数学运算符。想想我们之前提到的中不能重复其实也就好理解了。如果支持， 那相加的两个字典内值如果相同，那到底舍去那一个呢？法就更容易理解，原本就是将相同的数据重复乘n份，不支持也就理所应当了。

那么，字典到底支持哪些操作呢？我们接着往下看实验：

首先，让我们尝试获取一下元素，既然字典是形式的，那要想拿到值，必然是使用来获取：

res = ex1['a']

print(res)

---

1

拿到元素了，那如果我们是要修改元素呢？直接赋值试试：

ex1['a'] = 111

print(ex1)

---

{'a': 111, 'b': 2, 'c': 3}

看来是有效的，增删改查，我们现在来试试删除：

del ex1['a']

print(ex1)

---

{'b': 2, 'c': 3}

也没毛病。

接下来，当然就是添加元素了：

ex1['aa']  = 'aaaaa'

print(ex1)

---

{'b': 2, 'c': 3, 'aa': 'aaaaa'}

之前我们反复说过字典的一个特点，就是字典不能有重复的，这也是我们无法使用和操作字典的原因。那么问题来了，如果我在添加元素的时候重复了怎么办？

什么怎么办，添加重复了，那不就变成修改元素了吗？

检测和获取

增删改查我们前三个基本都已经讲完了，那剩下的，就是查了。让我们看看如何检测和获取元素。

成员检测，只能检测， 无法检测。是否注意到我们之前一直使用的一句代码, 大家应该都能明白这一句代码是做什么吧？其实，我们坚持是否包含的时候，就可以用来实现：

print('AA' in ex1)

print('AA' not in ex1)

---

False

True

获取当前字典的长度，只能检测当前有多少个健值对：

print(len(ex1))

---

3

我们还可以获取当前字典中的所有键：

print(ex1.keys())

---

dict_keys(['b', 'c', 'aa'])

当然，不只是。实际上，字典中所有的值，我们一样可以获取到：

print(ex1.values())

---

dict_values([2, 3, 'aaaaa'])

最后，让我们尝试把和一起获取到：

print(ex1.items())

---

dict_items([('b', 2), ('c', 3), ('aa', 'aaaaa')])

字典的遍历

当我们谈到对字典的遍历时，实际上和检测、获取时一样的。只是写进了遍历循环里而已，让我们来看看吧：

在我们遍历当前字典时，只能获取当前的, 但是我们可以通过获取到的来完成获取当前的:

for i in ex1:

   print(i, ':', ex1[i], end="; ")

---

b : 2; c : 3; aa : aaaaa;

这种获取方式就显得略微繁琐一点，既然我们之前有提到一个将和一起获取到的函数方法，那我们在里一样可以使用它来将和一起获取到，只是，我们需要用到两个参数来接收：

for k, v in ex1.items():

   print(k, ':', v, end="; ")

---

b : 2; c : 3; aa : aaaaa;

既然之前介绍的获取上我们可以单独获取和， 当然这里也通通能用：

# 遍历所有的key

for k in ex1.keys():

   print(k, end="; ")

print()

# 遍历所有的value

for v in ex1.values():

   print(v, end="; ")

---

b; c; aa;

2; 3; aaaaa;

字典的相关函数

和列表、元组一样，字典也有一些相关函数。有些嘛，一看到就很熟悉，在其他地方也能用，可是也有一些事字典专用的。

: 获取字典的健值对个数

获取当前字典的所有键，组成的列表

获取当前字典的所有值，组成的列表

返回由字典项（（键，值）对）组成一个新视图

返回以字典的键为元素的迭代器。

res = iter(ex1)

print(next(res))

print(list(res))

---

b

['c', 'aa']

接下来，让我们重新定义一个新的字典来继续下面的函数学习：

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

通过从当前字典中弹出健值对，删除。

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

myDict.pop('a')

print(myDict)

---

{'b': 2, 'c': 3, 'd': 4, 'e': 5}

这里我们需要注意一个点，就是这个函数其实是有返回值的，会返回当前删除的健值对的, 我们拿一个变量来接收一下返回值看看：

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

res = myDict.pop('a')

print(res)

---

1

可以看到，接收到了方法的返回值

: 后进先出（LIFO）的方式删除健值对，我们这里需要理解一下什么叫后进先出，就是最后一个加入字典的元素，先出来。

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

myDict.popitem()

print(myDict)

---

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

和方法一样，方法也会有一个返回值，不过是返回一个元组。

res = myDict.popitem()

print(res)

---

('e', 5)

上面我们在讲获取的时候提到，可以直接使用来获取元素的， 不过如果字典内如果没有这个的话，程序会报错。除了使用来直接获取，字典里还有一个方法可以用来获取一个元素，用获取元素存在就返回，不存在也不回报错，而是回返回

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

print(myDict.keys('f'))

---

TypeError: dict.keys() takes no arguments (1 given)

============

# get方法获取

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

print(myDict.get('f'))

---

None

字典的方法可以更新对字典进行更新，如果这个存在的话，就是更新。如果不存在，则会进行添加。可是使用的形式更新，也可以直接获取一个新字典进行更新。

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

myDict.update(a=11, b=22)

myDict.update({'c':33, 'f':66})

print(myDict)

---

{'a': 11, 'b': 22, 'c': 33, 'd': 4, 'e': 5, 'f': 66}

实际上可以这么理解，update方法在获取其他字典更新原字典就有点像使用数学运算符的+, 区别只是，update是强制把最终确定值定为 + 号后方的值。

字典中还有一个方法, 完整的写法为:这个方法会去字典中找寻存在的，并且会返回它的值。如果这个不存在，这会插入一个值为的， 并且返回:

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

res = myDict.setdefault('aa', '123')

print(res)

res = myDict.setdefault('a', 2)

print(res)

print(myDict)

---

123

1

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'aa': '123'}

需要注意的是，如果这个在字典中本来就存在，则并不会修改原本的值，即便你在后面设定了一个。并且返回的也会是字典内原本的。也就是说，这个方法只能用来查询和新增。

字典推导式

和之前介绍的数据类型一样，字典也可以使用推导式来实现一些功能。比如：

字典中的健值对位置进行交换，先用普通的方法实现：

myDict = {'a':1, 'b':2, 'c':3}

newDict = {}

for k, v in myDict.items():

   newDict[v] = k

print(newDict)

---

{1: 'a', 2: 'b', 3: 'c'}

然后再让我们看看字典推导式如何完成：

myDict = {'a':1, 'b':2, 'c':3}

newDict = {v:k for k, v in myDict.items()}

print(newDict)

---

{1: 'a', 2: 'b', 3: 'c'}

有的小伙伴可能会在推导式前方只写了一个变量来进行接收，那会变成什么样呢？我们来看看：

myDict = {'a':1, 'b':2, 'c':3}

newDict = {v for k, v in myDict.items()}

print(newDict, type(newDict))

---

{1, 2, 3}

可以看到，最终打印的字典似乎看起来怪怪的，不是的对形式，而是只有一个值。我们一下能看到，类型并非是字典，而是， 也就是说这是一个集合。

来让我们再看一个案例，让我们把一个字典中的值有偶数的对保留下来，并且交换健值对的位置，一样的，让我们先用普通方式做一遍：

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}

# 使用普通方式完成

newDict = {}

for k,v in myDict.items():

   if v%2 == 0:

       newDict[v] = k

print(newDict)

再让我们使用字典推导式来完成

newDict = {v:k for k,v in myDict.items() if v%2 == 0}

print(newDict)

---

{2: 'b', 4: 'd', 6: 'f'}

OK，关于字典的东西基本上也就这么多。在前面学习过字符串和列表之后，是不是其他的容器类数据就没那么难了？很多东西都是普遍适用的，所以我们要活学活用，多思考。

那今天就不留练习题了，咱们下节课是数据类型最后一节了，之后我们开始讲解具体实际应用。字符串和容器类数据是Python中的基础也是重点，大家一定要好好的巩固。

下一节：集合。咱们下节课再见。

关于Python内的数据及结构，如果还想更深入的研究，推荐大家看看这本书：