（小甲鱼python）字典笔记合集三 字典(下)总结 字典的(增删)改查 update()、items()、iter() 字典内部嵌套 字典推导式

一、基础复习

字典的增删在上节笔记中已写过：主要用到了fromkeys()等函数，
具体可以参考 字典(中)的总结

二、修改、查找字典中的元素(改和查)

1.直接修改字典键的值

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

2.使用update()修改
d.update()

>>> d
{'F': None, 'i': None, 's': 115, 'h': None, 'C': None}
>>> d.update(F='70',C='67')      # 修改键值对
>>> d
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}
>>> 

3.字典键查找
元素的查找

例：
d.get(‘c’,“这里没有c”) 查找的键没有时，显示后面的内容
d.setdefault(‘c’,“code”) 查找的键没有时，显示后面的内容,并将其作为键值对添加到字典中

>>> d
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}
>>> d['C']
'67'
>>> d['c']         #查找不存在的键时，会报错
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    d['c']
KeyError: 'c'
>>> d.get('c',"这里没有c")    # 查找的键没有时，显示后面的内容
'这里没有c'
>>> d.setdefault('C',"code")  
'67'
>>> d.setdefault('c',"code")  #查找的键没有时，显示后面的内容,并将其作为键值对添加到字典中
'code'
>>> d
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67', 'c': 'code'}
>>> 

4.字典键值对的获取

items() 获取字典的键值对
keys() 获取字典的键
values() 获取字典的值

代码如下：

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

5.字典的浅拷贝、获取字典键值对的数量、判断键是否在字典中

>>> e=d.copy()    #字典的浅拷贝
>>> e
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}
>>> len(d)      #获取字典键值对的数量
5
>>> 'C' in d    #判断键是否在字典中
True
>>> 'c' not in d
True

6.字典转换为列表、iter()函数、reversed()函数
字典转换为列表，得到的是字典中所有的键构成的列表

list(d.keys())=list(d)
list(d.values())

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

iter()函数：迭代器
iter是读取每一个对象，next是返回迭代器的下一个对象

>>> d
{'F': '70', 'i': 105, 's': 115, 'h': 104, 'C': '67'}
>>> 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 "<pyshell#53>", line 1, in <module>
    next(e)
StopIteration

reversed()函数
python 3.8之后的版本可以用

>>> list(d.values())
['70', 105, 115, 104, '67']
>>> list(reversed(d.values()))
['67',104,115,105,'70']
>>>

7.字典内部嵌套

字典嵌套字典，访问需要两次。第一次输入外部字典的键，第二次输入内部字典的键
字典嵌套列表，第一次输入外部字典的键，第二次索引列表的下标索引

>>> d={"吕布":{"语文":60,"数学":70,"英语":80},"关羽":{"语文":80,"数学":90,"英语":70}}
>>> d["吕布"]["数学"]    #字典嵌套字典，第一次输入外部字典的键，第二次输入内部字典的键
70
>>> 
>>> d={"吕布":[60,70,80],"关羽":[80,90,70]}  # 字典嵌套列表，
>>> d["吕布"][1]           #第一次输入外部字典的键，第二次索引列表的下标索引
70

8.字典推导式

>>> 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}     # 加上筛选
>>> 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}
#双重for循环，x=1的时候，y一直检索到6，将前面的2,4覆盖，x=3、x=5同理
>>> d={x:y for x in [1,3,5] for y in [2,4,6]}
>>> d
{1: 6, 3: 6, 5: 6}
>>> 

课后题：
1.请问可以使用下面方法来更新字典的值吗？

>>> d = dict.fromkeys("FishC")
>>> d.update([('F',70), ('i',105), ('s',115), ('h',104), ('C',67)])

答：可以。
解析：字典的 update() 方法，可以同时给它传入多个键值对，也可以直接给它传入另外一个字典，或者一个包含键值对的可迭代对象，下面这三种方法都可以用。

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

2. 请问下面代码执行之后，变量 e 的内容是？

>>> d = {"小甲鱼":"千年王八，万年龟。"}
>>> e = d.copy()
>>> d["小甲鱼"] = "666"

答：

>>> e
{'小甲鱼': '千年王八，万年龟。'}

解析：其实这跟列表的道理是一样的，浅拷贝第一层的修改是不会相互影响的，但是对于嵌套层，可就不是这么一回事咯。

>>> d = {"小甲鱼":{"千年王八":"万年龟"}}
>>> e = d.copy()
>>> d["小甲鱼"]["千年王八"] = "666"
>>> e
{'小甲鱼': {'千年王八': '666'}}

3.请问下面代码执行之后，字典 d 的内容是？

>>> d = {}
>>> d[1] = "千年王八"
>>> d[1.0] = "万年龟"

答：

>>> d
{1: '万年龟'}

解析：字典是基于散列表实现的，由于 “键的值如果相等，哈希值就必须一致” 的原理，所以 1.0 和 1 在字典中认为是同一个键，对同一个键进行重复赋值，Python 会用新的值去覆盖旧的值。

4. items()、keys() 和 values() 三个方法分别用于获取字典的键值对、键和值三者的视图对象，你如何理解 “视图对象“ 的含义？

答：视图对象就是字典的一个动态视图，这意味着当字典内容改变时，视图对象的内容也会相应地跟着改变。
5. 请问如何判断某一个值是否在字典中？
答：

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

6. 请问下面演示的代码，为什么字典 d 打印出来的结果是这样的？

>>> for x in [1, 3, 5]:
...     for y in [2, 4, 6]:
...         print(f"d[{x}] = {y}")
...         d[x] = y
...                
d[1] = 2
d[1] = 4
d[1] = 6
d[3] = 2
d[3] = 4
d[3] = 6
d[5] = 2
d[5] = 4
d[5] = 6
>>> d
{1: 6, 3: 6, 5: 6}

解析：看出来了吗？还不是因为一个键必须是唯一的，所以每个键都被覆盖了两次~

题目来自小甲鱼python字典(下)