五：《Python基础语法汇总》— 字典和序列操作

一：字典

• ​ 字典是Python中最基本的数据类型之一，是可以存放多个键值对的容器
• ​ 字典是Python中序列的一种，是一个可变的有序序列
• ​ 字典中一个键可以对应多个值，但不能一个值对应多个键
• ​ 字典可以转换成其它的序列，但其它的序列不能转换成字典

创建字典：

a = {键:值,键:值......} #键只能是不可变类型；值可以是任何的类型

创建空字典的两种方式：

a = {}
a = dict()

用一个键去存储多个值：

a = {"数字":(1,2,3,"无穷")}
print(a["数字"]) #会返回这个键所对应的所有的值

1.索引：

​ 像其它的序列都是直接存储在内存中，Python会给它们分配一个编号。但在字典中只有键是直接存储在内存中，而值是储存在键中的。所以字典是没有下标的，都是通过键去索引从而进行操作的

通过索引实现查找/修改/增加：变量名[键] / 变量名[键] = 值 / 变量名[键] = 值

#查找值
a = {"嘟嘟":520,"咕咕":1314}
print(a["咕咕"])
#修改值
a["咕咕"] = 12345
print(a)
#增加新的键值对
a["嘻嘻"] = 100
print(a)

​ 注意：

（1）当用键去索引时如果这个键存在则返回其对应的值

（2）当用键去索引时如果这个键存在并把这个键赋予新的值时，则会修改原本的值

（3）当用键去索引时如果这个键不存在并将其赋予值时，则会在末尾添加这个新的键值对

2.字典的方法与函数：

​ 字典的常用操作方法有增加，删除，修改，查找

一：增加

​ 通过键的索引去添加

​ 字典中新增加的键值对无法增加到指定的位置，都新加到最后一位

update()方法：将序列中的元素存储在字典中，一次可新建多个键值对

update()方法的语法格式：字典对象/变量名.update({键:值})

​ 注意： update()方法的参数是一个序列，不要忘记代表字典的大括号！！！

a = {"嘟嘟":520}
a.update({"咕咕":1314,"呼呼":"eee"})
print(a)

setdefault()方法：在字典的末尾增加一个键值对

setdefault()方法的语法格式：字典对象/变量名.setdefault(键,值)

a = {"嘟嘟":520,"咕咕":1314}
a.setdefault(520,1314)
print(a)

​ 注意：

（1）当setdefault()括号中的键不存在时，则在末尾新增一个默认值为None的键值对，也可以在setdefault()的第二个参数中添加想要添加的值。如果setdefault()括号中的键存在，那么无论是否添加值，都不会做任何的修改，因为setdefault()方法没有修改的作用

（2）setdefault()方法一次只能添加一个键值对

二：删除

​ 通过键的索引去删除

del销毁语句：销毁掉指定的这个字典或者其元素，释放内存空间

del的语法格式：

• del 字典名[要删除的键值对中的键]
• del 字典名

a = {"嘟嘟":520,"咕咕":1314}
del a["咕咕"] #销毁掉咕咕这个键值对
print(a)
del a #销毁a这个字典

pop()方法：通过指定键值对中的键去删除这个键值对

pop()方法的语法格式：字典对象/变量名.pop(要删除的键值对中的键)

a = {"嘟嘟":520,"咕咕":1314}
a.pop("咕咕")
print(a)

popitem()方法：默认删除字典当中最后的一个键值对，无法指定删除哪一个

popitem()方法的语法格式：字典对象/变量名.popitem()

a = {"嘟嘟":520,"咕咕":1314}
a.popitem()
print(a)

clear()方法：清空字典中的所有元素，只留下空字典

clear()方法的语法格式：字典对象/变量名.clear()

a = {"嘟嘟":520,"咕咕":1314}
a.clear()
print(a)

三：修改

​ 字典中的值可以重复，但字典中的键是不允许重复的，重复的话字典会取第一个定义的键，和将前面的值覆盖掉的最后定义的值

update()方法：将字典中键所对应的值修改

update()方法的语法格式：字典对象/变量名.update({键:值})

a = {"嘟嘟":520,"咕咕":1314}
a.update({"咕咕":"呃呃呃"})
print(a)

​ 注意： 如果这个键存在字典当中，那么update()方法的作用就是修改，如果这个键不存在，那么update()方法的作用就是在末尾增加一个键值对

四：查找

setdefault()方法：通过键查看这个键值对中的值

setdefault()方法的语法格式：字典对象/变量名.setdefault(键)

a = {"嘟嘟":520,"咕咕":1314}
a.setdefault("咕咕")
print(a)

​ 注意： 如果这个键存在字典当中，那么setdefault()方法的作用就是查看这个键值对中的值，如果这个键不存在，那么setdefault()方法的作用就是默认在末尾增加一个值为None的键值对

get()方法：通过键查看这个键值对中的值

get()方法的语法格式：字典对象/变量名.get(键)

a = {"嘟嘟":520,"咕咕":1314}
a.get("咕咕")
print(a)

​ 注意：

• 如果这个键存在字典当中，那么get()方法的作用就是查看这个键值对中的值，如果这个键不存在，那么get()方法会返回None
• get()方法与setdefault()方法的区别就是当查看的键不存在时，setdefault()方法会在键值对的末尾增加一个新的键值对，而get()不会

3.字典的遍历：

for 临时变量 in 字典名:

只遍历键：因为值是存储在键里的，所以当遍历字典的时候就只遍历了键

keys()方法：查看字典里所有键值对中的键

a = {"嘟嘟":520,"咕咕":1314,"呃呃":456,"切切":789}
for i in a:
    print(i)
#用keys()方法遍历键
a = {"嘟嘟":520,"咕咕":1314,"呃呃":456,"切切":789}
for i in a.keys():
    print(i)

只遍历值：

values()方法：查看字典里所有键值对中的值

a = {"嘟嘟":520,"咕咕":1314,"呃呃":456,"切切":789}
for i in a.values():
    print(i)

把一个键值对当成一个元素去遍历，查看所有的键值对

items()方法：返回一个元组

#去掉元组的两种方法：
#1.以两个变量去获取迭代的元组中的元素，第一个变量拿到第一个值，第二个变量拿到第二个值，以此类推
a = {"嘟嘟":520,"咕咕":1314,"呃呃":456,"切切":789}
for i,w in a.items():
    print(i,w)
#2.用下标索引去输出
a = {"嘟嘟":520,"咕咕":1314,"呃呃":456,"切切":789}
for i in a.items():
    print(i[0],i[1])
#直接以元组的形式输出
a = {"嘟嘟":520,"咕咕":1314,"呃呃":456,"切切":789}
for i in a.items():
    print(i)

4.字典推导式：

{键:值 for 临时变量 in 字典.items() if 条件判断}

#通过字典推导式快速的生成一个字典
a = {i:w for i,w in enumerate("hello",111)}
print(a)
b = {i:w for i,w in enumerate("hello",111) if i % 2 == 0}
print(b)

#将两个列表变成一个字典
a = ["name","age","sex"]
b = ["xxx",19,y]
c = {a[i]:b[i] for i in range(len(a))}
print(c)

#提取字典中大于200的目标数据
a = {"ccc":111,"bbb":890,"ddd",905,"eee":130}
m = {i:w for i,w in a.items() if w > 200}
print(a)

---

二：序列操作

1.运算符：

运算符	描述	支持的序列
+	元素的合并拼接	字符串，列表，元组
*	元素的复制重复	字符串，列表，元组
in	是否存在	字符串，列表，元组，字典，集合
not in	是否不存在	字符串，列表，元组，字典，集合

2.序列方法：

函数	描述
len()	统计序列中元素的个数
del 或 del()	销毁语句
max()	返回容器中元素最大值，不同类型之间不能进行比较
min()	返回容器中元素最小值，不同类型之间不能进行比较
range(x,y,z)	生成从x到y且不包括y的数字，步长为z
enumerate(x,y)	enumerate(x,y)是一个迭代器，不能直接去查看里面的数据。用于将一个可遍历的数据对象（如：列表，元组，字符串）组合为一个索引序列，同时以元组的形式返回该序列的元素和与其对应的下标，一般用在for循环中。x是序列，而y是指定的下标从哪里开始，不设置时默认为0。enumerate(x,y)方法生成的是一个下标在前，元素在后的元组！！！
sum()	序列求和
zip()	合并序列

#len()
print(len("12345"))
print(len(["12345",666]))
print(len(("12345",555)))
print(len({1,2,3}))
print(len({"1":2,"3":4}))

#max()和min()
print(max([1,3,6,7,23,12]))
print(max("14","65","90","33"))
print(min((132,43,68,95,34)))
#max()和min()也可以同时判断多个
      #当有多个同一类型的序列时，默认两个序列从第0索引元素开始比较。只要一个大，那整个序列就是大，不用进行后面的比较
print(max([1,3,6,7,23,12],[12,32,56]))
print(min({132,43,68,95,34},{55,57,87,10}))

#enumerate()
for i in enumerate("helloworld"):
      print(i) #返回的是以元组的形式输出的
	#去除元组输出
for i,w in enumerate("helloworld"):
      print(i,w)
#将helloworld以字典的形式存储的三种方法：
#第一种，索引赋值法
a = {}
for i,w in enumerate("helloworld",111):
    a[w] = i #因为enumerate(x,y)方法生成的是一个下标在前，元素在后的元组，所以是w = i，键 = 值
print(a)
#第二种，update()方法
a = {}
for i,w in enumerate("helloworld",0):
    a.update({w:i})
print(a)
#第三种，setdefault()方法
a = {}
for i,w in enumerate("helloworld",6):
    a.setdefault(w,i)
print(a)
#虽然enumerate()不能直接打印输出，但却可以把它转换成其它的类型去输出查看里面的数据
print(list(enumerate("helloworld")))