Python初学小知识（七）：字典

C语言和Python经常弄混，尤其总是忍不住给Python后面加分号……干脆给自己做个笔记省的忘了。。。（小甲鱼那边的）

十一、字典

1. 字典是Python中唯一实现映射关系的内置类型

>>> x = {'吕布':'口口布', '关羽':'关习习'}
>>> type(y)
<class 'list_iterator'>
>>> x['吕布']
'口口布'
>>> x['刘备'] = '刘文田'
>>> x
{'吕布': '口口布', '关羽': '关习习', '刘备': '刘文田'}

在定义里，我们使用花括号{}表示这是一个dict，然后key和value之间使用冒号:分割，并且每一组key:value的最后，以逗号,表示这一组的结束。

2. 创建字典

#一：直接生成键值对
>>> a = {'A':'apple', 'B':'boy', 'C':'cat'}
>>> a
{'A': 'apple', 'B': 'boy', 'C': 'cat'}

#二：使用dict()函数
>>> b = dict(A='apple', B='boy', C='cat')  #此时要求键上面不加引号，冒号改成等于号

#三：使用列表作为参数
>>> c = dict([('A', 'apple'), ('B', 'boy'), ('C', 'cat')])

#四：将第一种方法作为参数传递给dict()函数
>>> d = dict({'A':'apple', 'B':'boy', 'C':'cat'})

#五：混合
>>> e = dict({'A':'apple', 'B':'boy'}, C='cat')

#六：zip()创建迭代器
>>> f = dict(zip(['A', 'B', 'C'], ['apple', 'boy', 'cat']))

以上六种方法等价

3. 字典的增删改查

3.1 增 fromkeys(iterable[, values])

>>> d = dict.fromkeys('Fish', 250)  #从无到有，创建一个所有值都相同的一个字典
>>> d
{'F': 250, 'i': 250, 's': 250, 'h': 250}  #此时每个键对应的都是250，因为我们只给了这一个值
>>> d['F'] = 70  #修改某个键的值
>>> d
{'F': 70, 'i': 250, 's': 250, 'h': 250}
>>> d['C'] = 67  #增加一个新的键值对
>>> d
{'F': 70, 'i': 250, 's': 250, 'h': 250, 'C': 67}

后续在8.2中也讲了append()增加的方法。
序列和字典的另一个重大区别：序列中，元素可以重复；而字典中的键值对不会存在重复的键，如果重复了，就覆盖。

3.2 删

3.2.1 pop(key[, default])

>>> d = {'F': 70, 'i': 250, 's': 250, 'h': 250, 'C': 67}
>>> d.pop('s')  
250
>>> d
{'F': 70, 'i': 250, 'h': 250, 'C': 67}

#如果是pop一个不存在的键，就会发生异常：
>>> d.pop('a')
Traceback (most recent call last):
  File "", line 1, in <module>
    d.pop('a')
KeyError: 'a'
#可以加上一个default：
>>> d.pop('a', 'There is nothing')
'There is nothing'

>>> d.popitem()  #popitem()函数删除最后一个键值对（python3.7以上）
('C', 67)
>>> d
{'F': 70, 'i': 250, 'h': 250}

3.2.2 del关键字

>>> d = {'F': 70, 'i': 250, 'h': 250}
>>> del d['i']  #删除某元素
>>> d
{'F': 70, 'h': 250}

>>> del d  #删除整个字典
>>> d
Traceback (most recent call last):
  File "", line 1, in <module>
    d
NameError: name 'd' is not defined

3.2.3 clear()清空

>>> d = dict.fromkeys('FishC', 250)
>>> d
{'F': 250, 'i': 250, 's': 250, 'h': 250, 'C': 250}
>>> d.clear()
>>> d
{}

3.3 改

直接通过键值对改：

>>> d = dict.fromkeys('FishC')
>>> d
{'F': None, 'i': None, 's': None, 'h': None, 'C': None}  #此时对应的值都是None
>>> d['s'] = 115
>>> d
{'F': None, 'i': None, 's': 115, 'h': None, 'C': None}

批量修改：

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

3.4 查

根据键查值：

>>> d = {'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}
>>> d['C']  
'67'

get(key[, default])：上面的根据键查值如果是查到不存在的键，会报错，使用get()函数避免报错

>>> d.get('c', "There isn't c")
"There isn't c"

#也可以不加default，但是需要print：
>>> d.get('c')  #只是一个d.get('c')，不会出什么结果
>>> 
>>> print(d.get('c'))  #但是如果要打印出来，就是默认None
None

setdefault(key[, default])：查找键是否存在字典中，如果在，返回值；如果不在，给一个新的值

>>> d.setdefault('C', 'code')  #C存在
'67'
>>> d.setdefault('c', 'code')  #c不存在
'code'
>>> d
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67', 'c': 'code'}  #添加了c

4. 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，相应的键、值、键值对也会跟着改变：

>>> d.pop('c')
'code'
>>> d
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}
>>> 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'])

4.1 key不可变

对于基础数据类型，字符串、数字等，这些都是不可变的，可以作为dict的key，而对于复杂数据类型，经过前面的学习，我们知道tuple是不可变的，list是可变的，因此tuple可以作为dict的key，但是list不可以作为dict的key，否则将会报错。

5. 浅拷贝

>>> e = d.copy()
>>> e
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}

6. 其他函数

6.1 获取键值对的数量

>>> len(d)
5

6.2 判断某个键是否存在

>>> 'C' in d
True
>>> 'c' in d
False
>>> 'C' not in d
False

6.3 字典转化为列表

>>> list(d)
['F', 'i', 's', 'h', 'C']  #得到的是键构成的列表，相当于list(d.keys())

>>> list(d.values())  #得到值构成的列表
['70', 105, 115, 104, '67']

6.4 将字典构成迭代器

>>> e = iter(d)
>>> next(e)
'F'
>>> next(e)
'i'
>>> next(e)
's'
>>> next(e)
'h'
>>> next(e)
'C'
>>> next(e)
Traceback (most recent call last):
  File "", line 1, in <module>
    next(e)
StopIteration

7. python3.8之后，可以对字典进行排序

>>> d
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}
>>> list(reversed(d.values()))
['67', 104, 115, 105, '70']
>>> list(reversed(d))
['C', 'h', 's', 'i', 'F']
>>> list(reversed(d.items()))
[('C', '67'), ('h', 104), ('s', 115), ('i', 105), ('F', '70')]

在Python3.5之前，dict中的元素是无序的，也就是dict中元素的插入顺序和打印顺序未必一致，但是在Python3.6、Python3.7版本中，却得到了有序的结果。一般而言，为了避免不必要的误解，一般在需要有序的dict时，我们会使用一种叫做Ordereddict的字典，来确保有序。

8. 嵌套

8.1 字典嵌套字典

>>> d = {'Andy':{'Chinese':60, 'Math':70, 'English':80}, 'David':{'Chinese': 80, 'Math':90, 'English':70}}
>>> d
{'Andy': {'Chinese': 60, 'Math': 70, 'English': 80}, 'David': {'Chinese': 80, 'Math': 90, 'English': 70}}
>>> d['Andy']['Math']  #索引
70

8.2 字典嵌套列表

>>> d = {'Andy':[60, 70, 80], 'David':[80, 90, 70]}
>>> d['Andy'][1]
70

#此时可以继续添加列表中的元素：
>>> d['Andy'].append(85)
>>> d
{'Andy': [60, 70, 80, 85], 'David': [80, 90, 70]}

9. 字典推导式

>>> d = {'F':70, 'i':105, 's':115, 'h':104, 'C':67}
>>> b = {v:k for k, v in d.items()}  #每一次从d里面拿出键和值，对调
>>> b
{70: 'F', 105: 'i', 115: 's', 104: 'h', 67: 'C'}

>>> c = {v:k for k, v in d.items() if v > 100}  #值小于100的就不见了
>>> c
{105: 'i', 115: 's', 104: 'h'}

>>> d = {x:ord(x) for x in 'FishC'}  #调用编码值
>>> d
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'C': 67}

>>> l = [(x,y) for x in [1,2,3] for y in [4,5,6]]
>>> l
[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
>>> d = {x:y for x in [1,2,3] for y in [4,5,6]}
>>> d
{1: 6, 2: 6, 3: 6}  #字典调用出来的和列表的不太一样

10. 字典的特点

10.1 查找速度快

无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

10.2 占用内存大

不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。