小甲鱼——字典

字典是ipython当中唯一实现映射关系的内置类型。

映射关系：就是一一对应

y = {"吕布":"口口布","关羽":"关习习"}
type(y)
<class 'dict'>

这个就是一个字典，我们将冒号左边的就称之为字典的“键”，冒号右边的就是字典的值，

与序列不同的是，序列是通过位置的偏移来存取数据的，而字典是通过键来实现写入和读取的，

在字典中，只要我们提供键就可以获取其对应的值，方法与序列类似

y["吕布"]

这段代码的返回值就是   "口口布"

我们可以通过指定一个不存在于字典中的“键”来创建一个新的键值对，

y["刘备"] = "刘baby"


那么这段代码的返回值就是：
{'吕布'：'口口布','关羽':'关习习','刘备':'刘baby'}

进行字典的深度讲解：

一.创建字典：

1.直接使用大括号或者冒号组合，将映射关系展现出来。

 a = {'吕布'：'口口布','关羽':'关习习','刘备':'刘baby'}

2.使用dict()函数，这个函数，它是用来生成字典的，它的每个参数，都是一个对应的键值对，键与值之间，直接使用等号进行挂钩

b = dict(吕布 = "口口布"，关羽 = "关习习"，刘备 = "刘baby")

#注意#  这种写法不能在键上面添加引号。

3.使用列表作为参数，列表当中的每个元素是使用元组包裹起来的键值对。

c = dict([("吕布","口口布")，("关羽","关习习")，("刘备","刘baby")])

4.就是将第一种方法作为参数传递给dict

d = dict({'吕布'：'口口布','关羽':'关习习','刘备':'刘baby'})

5.前面跟第四种是一样的，后面又不太一样

e = dict({'吕布'：'口口布','关羽':'关习习'},刘备 = "刘baby")

6.zip()函数，它的作用就是：创建一个聚合多个可迭代对象的迭代器，那么他也是可以作为参数传递给dict()函数，

f = dict(zip(["吕布"，"关羽","刘备"]，["口口布","关习习","刘baby"]))

那么其实这六种他们是等价的

二.增

1.fromkeys(iterable[,values])

它可以使用iterable参数，指定的可迭代对象来创建一个新的字典，并将所有的值初始化为values参数指定的值

d = dict.fromkeys("Fish",250)


这段代码的返回值就是：
{'F':250,'i':250,'s':250,'h':250}

现在d就是存放四组映射关系的一个字典。他对于快速初始化一个字典是非常有效果的。

如果需要修改某个键的值，我们可以这么做

d['F'] = 70


那么这段代码的返回值就是
{'F':70,'i':250,'s':250,'h':250}

这个F的值就改过来了。

如果在字典中找不到对应的键，同样的操作就会变成增加一个键值对，

d['c'] = 67

这段代码的返回值就是:
{'F':70,'i':250,'s':250,'h':250,'c':67}

序列和字典的另一个重大区别：就是序列中元素可以是重复的，而字典中的项也就是我们说的键值对，它一个键就是对应一个值，并不会存在重复的键。如果重复了，就用新的值去覆盖旧的值。

2.删

删除字典中指定的元素，我们可以使用pop方法，

{'F':70,'i':250,'s':250,'h':250,'c':67}

d.pop('s')

这段代码返回的值就是：250  就是指定的键对应的值

我们看一下d 
d的返回值就是：
{'F':70,'i':250,'h':250,'c':67}
此时s就已经不见了

但是，如果pop一个不存在的键，就会抛出异常

d.pop("狗")   例如，你去抛出”狗“，但是里面本来就没有狗，此时就会抛出异常，但是如果你想让python不这么偏激，你可以给他指定一个这个default参数

d.pop("狗","没有")

它的返回值就是'没有'
那么在没有的时候，他就会返回我们指定的这个内容就是"没有"

与pop方法类似的还有popitem

它的作用就是，删除最后一个假如字典的键值对，因为在python3.7之后，他就把字典变成有序的了，但是呢，咱们开发的时候一定要记住，并不是所有去执行你这个源代码的这个编译器，它都是python3.7之后的，

{'F':70,'i':250,'s':250,'h':250,'c':67}
d.popitem()
('c',67)#这样就是将最后一个键值对弹出

此时的d就是
{'F':70,'i':250,'h':250}

del也可以删除一个指定的键值对

del d['i']

d


{'F':70,'h':250}

这样就是把i也删掉了

当然，del也可以直接加上字典的名字，把整个字典给干掉

最后，如果我们希望清空字典的内容，我们可以使用clear（）方法

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

那么此时d就变成了一个空字典。

3.改

只需要指定一个存在于字典中的键，就可以修改其对应的值

d = dict.fromkeys("FishC")  #先使用fromkeys去生成一个字典

d

{'F':None,'i':None,'s':None,'h':None,'C':None}  #那么一般情况下，他们的返回值就是None

#现在我们修改一下's'这个键的值

d['s'] = 115

d

{'F':None,'i':None,'s':115,'h':None,'C':None} 

但是如果我们想同时修改多个键值对，我们可以使用字典的update()方法

它可以支持你，同时给它传入多个键值对，，也可以直接给他传入另一个字典，或者一个包含键值对的可迭代对象，

d.update({'i':105,'h':104})#传入另外一个字典对他进行覆盖
d
{'F':None,'i':None,'s':105,'h':104,'C':None} 
#这个时候这个's','h'就直接更新上去了，还可以这么写：

d.update(F = '70',C = '67')

d

{'F':70,'i':105,'s':115,'h':104,'C':67} 

二.查

最简单的办法 

d['c']

'67'

如果我指定的键不在字典中，就会报错，有些时候会被认为是用户体验不佳的表现，所以更好的办法是使用get()方法

get(key[,default])

这个它可以存入一个default方法，指定，当找不到键的时候返回的值

d.get('c'，"这里没有c")   #查找c

这段代码的返回值就是：‘这里没有c’，不会报错

当我们需要查找一个键是否存在于字典当中时，如果在，返回对应的值，如果不在，就给它一个新的值，那么这个时候我们可以使用一个叫做，setdefault（）的方法，

d.setdefault('C',"code")   #查找大写字母C这个键  字典中是存在这个键的，所以后面输入的code并没有用
所以我们这段代码的返回值依旧是  '67'

d.setdefault('c',"code")   #查找小写字母c这个键  字典中是不存在这个键的

那么这段代码就会返回 "code"

#这时候我们将字典打印出来，会发现，字典发生了变化
d

{'F':'70','i':'105','h':'104','C':'67','c':'code'}

三.    items（），keys（），values（）

三个方法分别用于获取字典的键值对，键和值三者的视图对象

什么是视图对象:

视图对象即字典的动态视图，这就意味者当字典内容发生变化的时候，试图对象的内容也会相应地跟着改变。举个例子：

#创建三个视图对象
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.pop('c')   #把  c剔除出去

'code'
将字典打印出来，发现他改变了
d

{'F':'70','i':'105','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   #改变了

['70',105,115,104,'67']

字典为了实现浅拷贝，字典和序列一样，使用从copy方法

e = d.copy()
e

这段代码的返回值就是：
{'F':'70','i':105,'s':115,'h':104 'C':'67'}

四.内置函数

1.len()

这个内置函数可以获取字典中键值对的数量，

{'F':'70','i':105,'s':115,'h':104 'C':'67'}

len(d)

5

2.  in    not in 

判断某个键是否存在于字典中

'C'in d
True
'c' not in d 
True

3.字典转换成列表  list(d)

list(d)

['F','i','s','h','C']   #这个时候得到的是字典中所有的键构成的列表相当于‘list(d.keys())’

#如果要得到所有值，应该使用的是什么

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

4.iter()函数

它的作用是将字典的键构成一个迭代器，

e = iter(d)
next(e)
'F'
next(e)
'i'
next(e)
's'
next(e)
'h'
next(e)
'C'

迭代器他只能走一遍，数到最后就会出现一个异常

5,python3.8版本之后，我们可以使用reversed（）函数，对字典内部的键值对进行逆向操作。

在之前的版本python因为它的字典的顺序是得不到保障的，所以我们不能使用reverse方法

因为无序，就无所谓的逆向排序，

list(reversed(d.values()))

['67',104,115,105,'70']

d = {"吕布":{"语文":60,"数学":70,"英语":80}，"关羽"：{"语文"：80，"数学"：90，"英语"：70}}

d
{"吕布":{"语文":60,"数学":70,"英语":80}，"关羽"：{"语文"：80，"数学"：90，"英语"：70}}

这个时候要是想要获取吕布的成绩，就需要做两次索引
d["吕布"]["数学"]
70   #得到的就是70分

 嵌套也可以嵌套一个序列：

d = {"吕布":[60,70,80]，"关羽"：[80,90,70]

#那么第二次索引我们应该相应的换成下标索引值

d["吕布"][1]
70

五.字典推导式

d = {'F':70,'i':105,'s':115,'h':104,'C':67}
b = {v:k for k,v in d.items()}
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:'5',104:'h'}
#两个小于100的就不见了

利用字典推导式，可以利用python求出字符串的编码值

d = {x:ord(x) for x in "FishC"}

d

{'F':70,'i':105,'s':115,'h':104,'C':67}

容易出错的地方：

d = {x:y for x in [1,3,5] for y in [2,4,6]}

d
{1:6,3：6，5：6}