字典类型是根据一个信息查找到另一个信息的方式构成了’键值对‘，他表示索引用的键和对应的值构成的对应关系
key — value
字典也是可变数据类型（另一个是列表）
字典中的元素是无序的，底层使用了hash：第一个添加到字典中的元素，在内存中不一定是第一个
键必须唯一，value可以重复
键必须是不可变序列：字符串、整数、浮点、元组 可以作为键，列表不可以做为字典的键
1、使用 {} 直接创建字典
d={key1:value1,key2:value2...}
2、使用内置函数dict()创建字典
dict(key1=value1,key2=value2...)
3、使用映射函数创建字典
zip(lst1,lst2)
'''
lst1和lst2都是列表，分别作为key和value
'''
代码实例：
# 字典的创建和删除
# （1）创建字典
d={10:'cat',20:'dog',30:'cat'}
print(d)
# 如果key重复,后面key的value会对前面的进行覆盖
d={10:'cat',20:'dog',30:'cat',20:'zoo'}
print(d)
# （2）使用参数创建字典 dict()
d=dict(cat=10,dog=20)
print(d)
# （3）zip函数映射创建
lst1=[10,20,30,40]
lst2=['cat','dog','pet','zoo','car'] # 此处多了一个元素
zipobj=zip(lst1,lst2)
print(zipobj) # <zip object at 0x0000011E60D4CC40>
#print(list(zipobj)) # 转成列表类型，元素是元组类型
print(dict(zipobj)) # 上面那行若不只是，映射对象zipobj已经转成列表类型，不能再转成字典类型了，因为已经没有元素了
# 使用整个元组作为键
t=(10,20,30)
print({t:10})
# 列表是不能做键的，没有哈希，可能会报错
# 可变数据类型不能作为字典中的键
# 字典属于序列，序列的操作方法同样适用于字典
print('max:',max(d))
print('min:',min(d))
print('len:',len(d))
# 字典的删除
del d
print(d) # 删除了之后就不能使用了 执行此句会报错
字典元素的取值：
d[key]
或者
d.get(key)
字典元素的遍历：
1）遍历出key与value的元组
for element in d.items():
pass
for key,value in d.items():
pass
代码实例：
# 字典元素的访问和遍历
d={'hello':10,'world':20,'python':30}
# 访问元素
# 二者之间有区别，若键不存在，第一种方法会报错
print(d['hello'])
print(d.get('hello'))
#print(d['java']) # 此处会报错，键不存在
print(d.get('java')) # 虽然键不存在，但是不会报错，返回 None
print(d.get('java'),'不存在') # 若键不存在，则会输出逗号后面的默认值
# 字典的遍历
for item in d.items():
print(item) # 得到由键和value组成的一个个元组
for key,value in d.items():
print(key,'-->',value)
| 字典的方法 | 描述说明 |
|---|---|
| d.keys() | 获取所有key数据 |
| d.values() | 获取所有的value数据 |
| d.pop(key,default) | key存在获取相应的value，同时删除key-value对，否则获default默认值 |
| d.popitem() | 随机从字典取出一个key-value对，结果为元组类型，同时将该key-value从字典中删除 |
| d.clear() | 清空字典中所有的key-value对 |
代码实例：
# 字典的相关操作方法
d={1001:'李梅',1002:'王华',1003:'张锋'}
print(d)
# 向字典中添加元素
d[1004]='张丽丽'
print(d)
keys=d.keys()
print(keys) # dict_keys([1001, 1002, 1003, 1004])
print(list(keys))
print(tuple(keys))
values=d.values()
print(values)
print(list(values))
print(tuple(values))
# 将字典中的数据转换成键值对的形式,以元组的方式展现
lst=list(d.items())
print(lst) # 列表的形式，元素是一个个元组
# 将上面的列表转换成字典
d=dict(lst)
print(d)
# pop 取出对应key的value，并删除这个key-value对
print(d.pop(1001))
print(d)
# 取一个不存在的key，并返回默认值
print(d.pop(1008,'不存在'))
# 随机删除
print(d.popitem())
print(d)
# 清空字典中的所有元素
d.clear()
print(d) # 变成空字典了
print(bool(d))
d={key:value for item in range}
d={key:value for key:value in zip(lst1,lst2)}
代码实例：
import random
d={item:random.randint(1,100) for item in range(4)}
print(d)
# 创建两个列表
lst=[1001,1002,1003]
lst2=['a','b','c']
d={key:value for key,value in zip(lst,lst2)}
print(d)
与数学中集合的概念一致
无序的、不重复的元素序列
只能存储不可变数据类型：可以存储字符串、整数、浮点数、元组，不能存储列表、字典
使用{}定义
与列表、字典一样，式可变数据类型
集合的创建方式有两种：
1、使用{}直接创建集合
s={element1,element2,...,elementN}
2、使用内置函数set()创建集合
s=set(可迭代对象)
集合的删除：
del 集合名
代码实例：
# 集合的创建和删除
# 使用{}直接创建集合
s={10,20,30}
print(s)
# 集合中只能存储不可变数据类型
# 列表，字典，集合式可变数据类型，因此不能作为集合的元素
# s={[10,20],[30,40]}
# print(s) # 此处会报错
# 使用set()去创建集合
s=set() # 没有参数，直接创建一个空集合
print(s) # set()
s={} # 直接使用花括号，创建的不是集合，是字典
print(s,type(s))
s=set('helloworld')
print(s) # 顺序被打乱，不会有重复的元素
s2=set([10,20,30])
print(s2)
s3=set(range(1,10))
print(s3)
# 序列的通用操作
print('max:',max(s3))
print('min:',min(s3))
print('len:',len(s3))
print('9存在于集合吗？',9 in s3)
print('9不存在于集合吗？',9 not in s3)
# 集合的删除操作
del s3
# print(s3) # 删除之后就不能再使用了，此句会报错，提示未定义
A&B 交集
A|B 并集
A-b 差集
A^B 补集
截图待补充
代码实例：
# 集合的操作符
A={10,20,30,40,50}
B={30,50,88,76,20}
# 交集
print(A&B)
# 并集
print(A|B)
# 差集
print(A-B)
# 补集
print(A^B)
| 集合的方法 | 描述说明 |
|---|---|
| s.add(x) | 若x不在集合s中，则将x添加到集合s |
| s.remove(x) | 若x在集合中，将其删除；若不在，则报错 |
| s.clear() | 清除集合中的所有元素 |
# 集合的相关操作
s={10,20,30}
# 像集合中添加元素
s.add(100)
print(s)
# 删除元素
s.remove(20)
print(s)
# 清空集合中所有元素
s.clear()
print(s) # set()
s={100,10,30}
# 集合的遍历操作
for item in s:
print(item)
for index,item in enumerate(s):
print(index,item)
# 集合的生成式
s={i for i in range(1,10)}
print(s)
s={i for i in range(1,10) if i%2==1}
print(s)
| 数据类型 | 序列类型 | 元素是否可以重复 | 是否有序 | 定义符号 |
|---|---|---|---|---|
| 列表list | 可变序列 | 可重复 | 有序 | [] |
| 元组tuple | 不可变序列 | 可重复 | 有序 | () |
| 字典dict | 可变序列 | key不可重复，value可重复 | 无序 | {key:value} |
| 集合set | 可变序列 | 不可重复 | 无序 | {} |
对整个数据结构进行模式匹配
match data:
case {}:
pass
case []:
pass
case ():
pass
case _:
pass
代码实例：
data=eval(input('请输入要匹配的数据'))
match data:
case {'name':'a','age':20}:
print('字典')
case [10,20,30]:
print('列表')
case (10,20,40):
print('元组')
case _:
print('相当于多重if中的else')
d1={'a':10,'b':20}
d2={'c':30,'d':40,'e':50}
d3=d1|d2
print(d3)
match data1,data2:
case data1,data2:
pass
代码实例：
fruits={'apple','orange','pear','grape'}
counts=[10,3,4,5]
for f,c in zip(fruits,counts):
match f,c:
case 'apple',10:
print('10个苹果')
case 'orange',3:
print('3个橘子')
case 'pear',4:
print('4个梨')
case 'grape',5:
print('5个葡萄')