字典是Python中唯一实现了映射关系的内置类型。
1、字典的特征
"""字典的关键符号是大括号（{}）和冒号（:）："""
>>> d = {"吕布":"口口布", "关羽":"关习习"}
>>> type(d)
<class 'dict'>
"""这里就是两对映射关系"""
我们将冒号的左边称为字典的 “键”(key)，右边称为字典的 “值”(value)。
访问字典中存储的数据只需要找到key：
>>> d = {"吕布":"口口布", "关羽":"关习习"}
>>> d["吕布"]
'口口布'
2、创建字典的六种方式
(1) 直接使用大括号和冒号的组合，将映射关系给“套牢”：
>>> a = {"吕布":"口口布", "关羽":"关习习", "刘备":"刘baby"}
(2) 使用 dict() 函数
>>> b = dict(吕布="口口布", 关羽="关习习", 刘备="刘baby")
(3) 使用列表作为参数，列表中的每个元素是使用元组包裹起来的键值对：
>>> c = dict([("吕布","口口布"), ("关羽","关习习"), ("刘备","刘baby")])
(4) 就是将第一种方法作为参数给到 dict() 函数：
>>> d = dict({"刘备": "刘baby", "关羽": "关习习", "吕布": "口口布"})
(5) 混合写法
>>> e = dict({"吕布":"口口布", "刘备":"刘baby"}, 关羽="关习习")
(6) zip() 函数
>>> f = dict(zip(["吕布","关羽","刘备"], ["口口布","关习习","刘baby"]))
字典的 增 删 改 查
增
首先是fromkeys(iterable[, value])方法，第一个参数是个可迭代对象，作为字典的key，第二个参数跟迭代器中依次取出的key建立映射关系，也就组成了字典。
>>> d = dict.fromkeys("Fish", 250)
>>> d
{'F': 250, 'i': 250, 's': 250, 'h': 250}
>>> a = dict.fromkeys([1,2,3],250)
>>> a
{1: 250, 2: 250, 3: 250}
如果不指定 value 参数，则采用默认值 None：
"""这种方法适用于从无到有创建一个字典，且所有的value都是同一个"""
>>> d = dict.fromkeys("Fish")
>>> d
{'F': None, 'i': None, 's': None, 'h': None}
如果字典中不存在对应的key，那么dict['key'] = 90 的作用是在字典末尾新增一个value是90的key
>>> d['C'] = 67
>>> d
{'F': 70, 'i': None, 's': None, 'h': None, 'C': 67}
删
pop()方法
>>> d.pop('s')
>>> d
{'F': None, 'i': None, 'h': None, 'C': 67}
如果 pop() 一个不存在的键，那么会抛出异常：
>>> d.pop("狗")
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
d.pop("狗")
KeyError: '狗'
"""上面的方法可以指定抛出的异常"""
>>> d.pop("狗", "没有~")
'没有~'
popitem()
在python3.7之前ppoitem()是从字典中随机删除一个key和它对应的value，3.7之后则是删除最后一个key和它对应的value
del关键字
del('key')=>删除key及其对应的value
如果 del 直接加上字典的变量名就是将整个字典给干掉：
>>> del d
>>> d
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
d
NameError: name 'd' is not defined
clear() 方法用于清空字典中的所有内容
>>> d = dict.fromkeys("FishC", 250)
>>> d
{'F': 250, 'i': 250, 's': 250, 'h': 250, 'C': 250}
>>> d.clear()
>>> d
{}
字典1.png
改
类似于序列的操作，只需要指定一个存在于字典中的键，就可以修改其对应的值：
>>> d = dict.fromkeys("FishC")
>>> d
{'F': None, 'i': None, 's': None, 'h': None, 'C': None}
>>> d['s'] = 115
>>> d
{'F': None, 'i': None, 's': 115, 'h': None, 'C': None}
上面的操作改一个key对应的value
update()可以改多个，只要给它传入多个键值对，或者一个包含键值对的可迭代对象，也可以直接传一个字典
>>> d.update({'i':105, 'h':104})
>>> d
{'F': None, 'i': 105, 's': 115, 'h': 104, 'C': None}
>>> d.update(F='70', C='67')
>>> d
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}
查
最简单的就是给一个key返回一个value
>>> d['C']
67
"""如果你指定的健不在字典中就会报错"""
>>> d['c']
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
d['c']
KeyError: 'c'
"""也可以自定义报错的内容"""
>>> d.get('c', "这里没有c")
'这里没有c'
"""有时候我们需要看一个key是不是在字典中，如果在返回他的值，如果不在可以给他指定一个新的值"""
>>> d.setdefault('C', "code")
67
>>> d
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67}
>>> d.setdefault('c', "code")
'code'
>>> d
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67, 'c': 'code'}
""和前面直接赋值的操作对比，这种方式不会直接破坏字典中原有的内容"""
3、视图对象
items()、keys() 和 values() 三个方法分别用于获取字典的键值对、键和值三者的视图对象。
视图对象就是字典的一个动态视图，这意味着当字典内容改变时，视图对象的内容也会相应地跟着改变。
"""items()方法获取的是字典对象的键值对"""
"""keys()方法获取的是字典对象的键"""
"""values()方法获取的是字典对象的值"""
>>> d
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67, 'c': 'code'}
>>> items = d.items()
>>> keys = d.keys()
>>> values = d.values()
>>> items
dict_items([('F', 70), ('i', 105), ('s', 115), ('h', 104), ('C', 67), ('c', 'code')])
>>> keys
dict_keys(['F', 'i', 's', 'h', 'C', 'c'])
>>> values
dict_values([70, 105, 115, 104, 67, 'code'])
>>> d.pop('c')
'code'
>>> items
dict_items([('F', 70), ('i', 105), ('s', 115), ('h', 104), ('C', 67)])
>>> keys
dict_keys(['F', 'i', 's', 'h', 'C'])
>>> values
dict_values([70, 105, 115, 104, 67])
可以用 len() 函数判断字典的长度（有几个键值对，长度就是几）
可以用 in & not in 判断一个key是否在字典中
可以用 list() 函数将一个字典转成列表（转换后是由key组成的列表）
>>> d = {'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67, 'c': 'code'}
>>> a = list(d)
>>> a
['F', 'i', 's', 'h', 'C', 'c']
"""如果想拿到values组成的列表，这样写"""
>>> b = list(d.values())
>>> b
[70, 105, 115, 104, 67, 'code']
"""如果想拿到键值对组成的列表，这样写，得到的是一个二维列表"""
>>> c = list(d.items())
>>> c
[('F', 70), ('i', 105), ('s', 115), ('h', 104), ('C', 67), ('c', 'code')]
字典对象可以放到 iter() 函数中来构造一个迭代器
"""再次验证迭代器是一次性的"""
>>> e = iter(d)
>>> next(e)
'F'
>>> next(e)
'i'
>>> next(e)
's'
>>> next(e)
'h'
>>> next(e)
'C'
>>> next(e,"啥都没有了")
'啥都没有了'
4、字典的嵌套
>>> d = {"吕布": {"语文":60, "数学":70, "英语":80}, "关羽": {"语文":80, "数学":90, "英语":70}}
>>> d["吕布"]["数学"]
70
"""如果嵌套的是一个列表"""
>>> d = {"吕布": [60, 70, 80], "关羽": [80, 90, 70]}
>>> d["吕布"][1]
70
5、字典推导式
"""只要循环体中in的后面是个可迭代对象，就可以使用循环的方式创建一个字典"""
>>> a = {k:v for k in range(10) for v in range(10)}
>>> a
{0: 9, 1: 9, 2: 9, 3: 9, 4: 9, 5: 9, 6: 9, 7: 9, 8: 9, 9: 9}
"""让推导式再加上判断条件"""
>>> a = {k:v for k in ["Jason","Louis","Apple","NASA"] for v in [101,139,89,29,109,110] if v > 100}
>>> a
{'Jason': 110, 'Louis': 110, 'Apple': 110, 'NASA': 110}
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>>> a = {k:v for k in ["Jason","Louis","Apple","NASA"] for v in [101,139,89,29,109,110] if v < 100}
>>> a
{'Jason': 29, 'Louis': 29, 'Apple': 29, 'NASA': 29}
"""用字典推导式求字符串对应的编码值"""
>>> a = {ord(i) for i in "Jason"}
>>> a
{97, 74, 110, 111, 115}
>>> a = {i:ord(i) for i in "Jason"}
>>> a
{'J': 74, 'a': 97, 's': 115, 'o': 111, 'n': 110}
get() 和 setdefault() 两个函数都可以判断一个字典中是否含有指定的key，不同的是 get() 函数如果找不到对应的key会报错，可以设置一个default内容来规避系统报错，而setdefault() 如果找不到对应的key则会往字典末尾加一个键值对，例如 a.setdefault(key,290) 如果找不到key的话就在字典a的末尾加一个key：290.
字典2.png
