元组、字典、集合
元组
概念：元组是一个不可变序列，无法增、删、改
创建元组：用tup=() 或 tup=tuple()
1、解包
含义：解包指的就是将元组当中每一个元素都赋值给一个变量
tup=(1,2,3,4)
a,b,c,d = tup
print(f'a={a},b={b},c={c},d={d}')
显示结果为：a=1,b=2,c=3,d=4
2、赋值交换
a=8
b=6
a,b=b,a
print(f'a={a},b={b}')
显示结果为：a=6,b=8
3、解包*
tup=(1,2,3,4,5,6,7)
a,b,*c=tup
print(f'a={a},b={b},c={c}')
显示结果为：a=1,b=2,c=[3, 4, 5, 6, 7]
字典
概念：字典是一种新的数据结构，称之为映射(mapping)
唯一的名字称之为键(key)
创建字典：用dic={}或 dic=dict()
字典存在键值对，键可以是任意不可变对象(int,str,bool,tuple...)
值可以是任意对象
1、双值子序列
dic=dict([('name','kml'),('age',18)])
print(dic)
显示结果：{'name': 'kml', 'age': 18}
dict()这个函数可以将一个包含有双值子序列转换成字典。
双值序列：序列中只有2个值
2、判断值是否在字典内
in或not in
判断字典中是否包含指定的键
dic=dict([('name','kml'),('age',18)])
if('name' in dic):
print('存在')
else:
print('不存在')
显示:存在
dic=dict([('name','kml'),('age',18)])
if('kml' in dic):
print('存在')
else:
print('不存在')
显示:不存在
3、方法
#clear()
dic=dict([('name','kml'),('age',18)])
dic.clear()
print(f'使用clear显示{dic}')
#copy()
dic2=dict([('name','kml'),('age',18)])
di=dic2.copy()
print(f'使用copy复制后ID:{id(di)},复制前ID:{id(dic2)}')
#fromkeys(iterable,value)
dic3=dict()
di=dic3.fromkeys((1,2),'wo')
print(f'使用fromkeys后:{di}')
#getself(key[,default])
dic4=dict([('name','kml'),('age',18)])
v=dic4.get('kml','不存在key')
print(f'使用getself显示:{v}')
#item()
dic5=dict([('name','kml'),('age',18)])
di=dic5.items()
print(f'使用item显示:{di}')
#keeys()
dic5=dict([('name','kml'),('age',18)])
v=dic5.keys()
print(f'使用keys显示:{v}')
#pop(k, d=None),如果K存在，返回对应的VALUE，并删除原字典对应键值
#如果K不存在，默认返回错误信息，下方返回不存在键值
dic6=dict([('name','kml'),('age',18)])
v=dic6.pop('name','不存在键值')
print(f'使用pop(k, d=None)显示:{dic6},返回值为:{v}')
#popitem() 默认删除某个键值对，并返回该键值对，用元组显示
dic7=dict([('name','kml'),('age',18),('sex','man')])
v=dic7.popitem()
print(f'使用popitem()显示:{dic7},返回值为:{v},返回值类型:{type(v)}')
#setdefault(k, d=None),检查是否存在K，如果存在直接返回DICT中对应的V，不做更新。否则新增一个，返回内容为新增的V
dic8=dict([('name','kml'),('age',18),('sex','man')])
v=dic8.setdefault('na','zx')
print(f'使用setdefault(k, d=None)显示:{dic8},返回值为:{v}')
#update(E=None, **F),没有的键，新增至dic9，如果存在，V不一致，更新V
dic9=dict([('name','kml'),('age',18),('sex','man')])
di=dict([('hight',10),('age',20)])
dic9.update(di)
print(f'使用update(E=None, **F)显示:{dic9}')
#values()
dic9=dict([('name','kml'),('age',18),('sex','man')])
di=dic9.values()
print(f'使用values()返回为:{di}')
#修改字典
dic10=dict([('name','kml'),('age',18),('sex','man')])
dic10['name']='zx'
print(f'修改后的字典为:{dic10}')
显示结果：使用clear显示{}
使用copy复制后ID:1927950955072,复制前ID:1927951846784
使用fromkeys后:{1: 'wo', 2: 'wo'}
使用getself显示:不存在key
使用item显示:dict_items([('name', 'kml'), ('age', 18)])
使用keys显示:dict_keys(['name', 'age'])
使用pop(k, d=None)显示:{'age': 18},返回值为:kml
使用popitem()显示:{'name': 'kml', 'age': 18},返回值为:('sex', 'man'),返回值类型:<class 'tuple'>
使用setdefault(k, d=None)显示:{'name': 'kml', 'age': 18, 'sex': 'man', 'na': 'zx'},返回值为:zx
使用update(E=None, **F)显示:{'name': 'kml', 'age': 20, 'sex': 'man', 'hight': 10}
使用values()返回为:dict_values(['kml', 18, 'man'])
修改后的字典为:{'name': 'zx', 'age': 18, 'sex': 'man'}
4、浅复制
只会复制字典本身，如果字典当中还有字典是不会被复制的
dic={
'name':'kk','shux':{
'age':18,'sex':'man'}}
dic2=dic.copy()
print(f'dic的id为：{id(dic)},dic2的id为：{id(dic2)}')
print('以下更改非子字典内容')
dic['name']='zx'
print(f'dic为：{dic}')
print(f'dic2为：{dic2}')
print('以下更改子字典内容')
v=dic['shux']
v['age']=20
print(f'dic为：{dic}')
print(f'dic2为：{dic2}')
显示结果：
dic的id为：2527798489664,dic2的id为：2527798490024
以下更改非子字典内容
dic为：{'name': 'zx', 'shux': {'age': 18, 'sex': 'man'}}
dic2为：{'name': 'kk', 'shux': {'age': 18, 'sex': 'man'}}
以下更改子字典内容
dic为：{'name': 'zx', 'shux': {'age': 20, 'sex': 'man'}}
dic2为：{'name': 'kk', 'shux': {'age': 20, 'sex': 'man'}}
集合
集合的表现形式 set
集合和列表基本一致
不同点
1.集合只能存储不可变对象
2.集合中存储的对象是无序的
3.集合中不能出现重复的元素
方法
s=('a','b','c')
se=set(s)
#add(self, *args, **kwargs),新增一个数
se.add('d')
print(f'add后的结果为：{se}')
#difference(self, *args, **kwargs),求差集，下中s1与se的差集，类似与符号-
s1={
'a','b','12'}
s2=s1.difference(se)
S2=s1-se
print(f'difference后的结果为：{s2},s1-se后的结果为：{S2}')
#difference_update(self, *args, **kwargs),求差集，将差集更新在此集合中
s1={
'a','b','12'}
s1.difference_update(se)
print(f'difference_update后的结果为：{s1}')
#discard(self, *args, **kwargs),删除指定的值
s1={
'a','b','12'}
s1.discard('a')
print(f'discard后的结果为：{s1}')
#intersection(self, *args, **kwargs)求交集，下中s1与se的交集，类似与符号&
s1={
'a','b','12'}
s=s1.intersection(se)
s2=s1&se
print(f'intersection后的结果为：{s},& 后的结果为：{s2}')
#intersection_update(self, *args, **kwargs)求交集，下中s1与se的交集,将结果返回第一个集合
s1={
'a','b','12'}
s1.intersection_update(se)
print(f'intersection_update后的结果为：{s1}')
#isdisjoint(self, *args, **kwargs) 判断两个函数是否存在交集，如果没有返回True,否则返回False
s1={
'a','b','12'}
result=s1.isdisjoint(se)
print(f'isdisjoint后的结果为：{result}')
#pop(self, *args, **kwargs) 移除一个元素，并返回该元素
s1={
'a','b','12'}
result=s1.pop()
print(f'pop后的结果为：{s1},返回值:{result}')
#remove(self, *args, **kwargs) 移除一个元素
s1={
'a','b','12'}
s1.remove('a')
print(f'remove后的结果为：{s1}')
#symmetric_difference(self, *args, **kwargs) 返回两个集合中不重复的元素集合,和^相同
s1={
'a','b','12'}
result=s1.symmetric_difference(se)
result1=se^s1
print(f'symmetric_difference后的结果为：{result},^的结果为：{result1}')
#symmetric_difference_update(self, *args, **kwargs)返回两个集合中不重复的元素集合，结果更新至此集合
s1={
'a','b','12'}
s1.symmetric_difference_update(se)
print(f'symmetric_difference_update后的结果为：{s1}')
#union(self, *args, **kwargs)返回两个函数的并集，与|相同
s1={
'a','b','12'}
result=s1.union(se)
result1=s1|se
print(f'union后的结果为：{result},| 的结果为：{result1}')
#update 添加可迭代的内容，结果更新至此集合
s1={
'a','b','12'}
s1.update(se)
print(f'update后的结果为：{s1}')
显示结果：
add后的结果为：{'a', 'b', 'd', 'c'}
difference后的结果为：{'12'},s1-se后的结果为：{'12'}
difference_update后的结果为：{'12'}
discard后的结果为：{'b', '12'}
intersection后的结果为：{'a', 'b'},& 后的结果为：{'a', 'b'}
intersection_update后的结果为：{'a', 'b'}
isdisjoint后的结果为：False
pop后的结果为：{'b', '12'},返回值:a
remove后的结果为：{'b', '12'}
symmetric_difference后的结果为：{'d', '12', 'c'},^的结果为：{'d', '12', 'c'}
symmetric_difference_update后的结果为：{'d', '12', 'c'}
union后的结果为：{'d', '12', 'a', 'b', 'c'},| 的结果为：{'d', '12', 'a', 'b', 'c'}
update后的结果为：{'d', '12', 'a', 'b', 'c'}