Hi，大家好。我是茶桁。

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

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

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

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

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

字典的定义

• 字典可以通过把以逗号分隔的key:value对列表包含于花括号之内来创建字典。
• 也可以通过dict构造器来创建

{'jack': 666, 'stored': 777} 或者{666:'jack', 777:'stored'}

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

使用{} 定义:

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

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

使用dict(key=value, key=value)函数进行定义

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

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

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

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位是必填项。

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

zip压缩函数，dict转类型

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'

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

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

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

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'}

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

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

检测和获取

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

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

print('AA' in ex1)
print('AA' not in ex1)

---
False
True

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

print(len(ex1))

---
3

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

print(ex1.keys())

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

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

print(ex1.values())

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

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

print(ex1.items())

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

字典的遍历

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

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

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

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

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

for k, v in ex1.items():
    print(k, ':', v, end="; ")

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

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

# 遍历所有的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; 

字典的相关函数

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

len(dict): 获取字典的健值对个数

dict.keys() 获取当前字典的所有key键，组成的列表

dict.values() 获取当前字典的所有value值，组成的列表

dict.items()返回由字典项（（键，值）对）组成一个新视图

iter(dict)返回以字典的键为元素的迭代器。

res = iter(ex1)
print(next(res))
print(list(res))

---
b
['c', 'aa']

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

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

dict.pop(key) 通过key从当前字典中弹出健值对，删除。

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
myDict.pop('a')
print(myDict)

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

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

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
res = myDict.pop('a')
print(res)

---
1

可以看到，res接收到了pop()方法的返回值1

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

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
myDict.popitem()
print(myDict)

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

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

res = myDict.popitem()
print(res)

---
('e', 5)

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

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

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

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是强制把最终确定值定为 + 号后方的值。

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

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'}

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

字典推导式

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

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

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} <class 'set'>

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

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

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中的基础也是重点，大家一定要好好的巩固。

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