JJJ：组合数据类型2

字典的创建和删除 p50

字典类型是根据一个信息查找到另一个信息的方式构成了’键值对‘，他表示索引用的键和对应的值构成的对应关系

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) # 删除了之后就不能使用了 执行此句会报错

字典元素的访问及遍历 p51

字典元素的取值：

d[key]
或者
d.get(key)

字典元素的遍历：
1）遍历出key与value的元组

for element in d.items():
	pass

2. 分别遍历出key和value

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)

字典操作的相关方法 p52

字典的方法	描述说明
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)

集合的创建与删除 p54

与数学中集合的概念一致

无序的、不重复的元素序列

只能存储不可变数据类型：可以存储字符串、整数、浮点数、元组，不能存储列表、字典

使用{}定义

与列表、字典一样，式可变数据类型

集合的创建方式有两种：

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) # 删除之后就不能再使用了，此句会报错，提示未定义

集合的操作符 p55

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)

集合的操作方法、集合的遍历 p56

集合的方法	描述说明
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	可变序列	不可重复	无序	{}

Python 3.11新特性

结构模型匹配

对整个数据结构进行模式匹配

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个葡萄')