Python编程Day6——元组类型、字典类型、集合

一、元组类型（tuple）

1、用途:记录多个值，当多个值没有改变的需求此时元组更为合适

2、定义：在（）内用逗号分隔开多个任意类型的值（参数为for可以循环的对象）

3、常用操作：

索引（正取向+反取向）且只能取值不能改变

t=('egon',123,['a','b'])
print(id(t[0]))
print(id(t[1]))
print(id(t[2]))
print(id(t[-1]))

 

切片（顾头不顾尾，步长）

print(id(t))
nt=t[::-1]
print(nt,id(nt))

　

长度len

print(len(t))

　　

成员运算in  not  in

循环

4、内置方法  # 该数据集合可以存放相同数据

print(t.count(2)) 
print(t.index(2,2,3))

　　

总结：元组属于有序、不可变类型

二、字典类型（dic）

1、用途：存放多个值，可以通过key取值

2、定义：key具有唯一性（重复会覆盖掉旧值），value可以重复

dict的key：可以为所有不可变类型：int float tuple str bool none
dict的value：可以为所有数据类型

3、常用操作:无索引、切片，用key来取值

增：key不存在

dic={}
dic['name']='mac'
print(dic)

　　

删

del dic['name']
print(dic)

　　

改：key已存在

dic['name']='big mac'
print(dic)

　　

查

print(dic['name'])

　　

4、内置方法

a、get取值*******

dic={'a':10,'b':20}
print(dic['c'])  # keyerror报错
res=dic.get('c') # 拥有默认值，none,可以避免错误
print(res)
res=dic.get('d','key不存在')# 可以自定义默认值****
print(res)

 

增：添加的参数字典，与dic可以重复，就是更新值，新key就是新增

dic.update({'a':100,'c':300})
print(dic)

　　

删：根据key删除指定对象，并返回删除对象的value

res=dic.pop('c')
print(res)

　　

b、复制

newdic=dic.copy()
print(newdic)

d1={'list':[1,2]}
d2=d1.copy()
print(id(d1),id(d1['list']))
print(id(d2),id(d2['list']))
d1['list'].append('abc')
print(d2)

c、随机删除，返回值是（key，value形式）

print(dic)
print(dic.popitem())
print(dic.popitem())
print(dic)

d、独自设置默认值

d11={'a':10,'teas':['owe原teas的基础上添加老师，如果没有，新建一个空teas']}
d11={'a':10}
# 添加老师  如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas
if 'teas'not in d11: #成员运算
    d11['teas']=[]
d11['teas'].append('egon')
d11['teas'].append('liuxx')
print(d11)

 

e、　定一个空字典

第一个参数：keys：list、tuple、str，
第二个参数是统一的默认value（如没定义value默认为none）
d10={}.fromkeys(['a','b','c'])
print(d10) #{'a','b','c':} 

　　

总结：字典属于无序、可变类型

三、集合（set）

1、用途：列数据集合：str、list、tuple、set 双列：dict

2、定义：无序存储：无key无index,无法取值

      可变数据类型，内部可以存放任意类型数据，但数据具有唯一性就是去重*****

3、常用操作

{}代表空字典，用set（）来创建空集合

s1={}
print(s1,type(s1))
s2=set('abc')
print(s2,type(s2))

　　

4、内置方法：与使用—集合间的运算（&|^ - <>==）

p_set={'a','b','c','egon'}
l_set={'x','y','z','egon'}

　　

res=p_set & l_set
print(res)
res=p_set.intersection(l_set)
print(res) # 输出{'egon'}

　　

并集   |

res=p_set| l_set
print(res)
res=p_set.union(l_set)
print(res) # 输出{'z','c','y','x','b','a','egon'}

　　

差集-

res=p_set -l_set
print(res)  # 输出三('a','b','c')
res=l_set.difference(p_set)
print(res) # 输出('x','y'.,'z')

　　

对称差集   ^

res=p_set^l_set
print(res)

res=p_set.symmetric_difference(l_set)
print(res) # 输出为{'y','a','b','x','z','c'}
print(p_set)
print(l_set)
p_set.difference_update(l_set) # 将运算结果赋值给调用者
p_set=p_set-l_set
print(p_set)   #  输出{'c','a','b'}

print(l_set) # 输出{'egon','z','y','x'}

 

5、添加删除操作

s=set()
s.add('abc')
s.add('xyz')
print(s)

res=s.pop()  # 随机删除一个ele元素
print(res)
if 'xyz'in s:
s.remove('xyz') # 有ele就删除，无ele出异常

 

6、案例与应用场景

# 1、多少人参加了课程 ：['owen','egon','liuxx']
# 2a 、都选了哪些课程？:['python','linux','java']
# 利用逻辑代码去重
names = []
for name, _ in class_map:
    # 判断列表中是否已存在，不存在才添加
    if name not in names:
        names.append(name)
print(names)

# 利用set去重
classes = set()
for _, cless in class_map:
    classes.add(cless)
classes = list(classes)
print(classes)
#

7、了解 ：父子set

sup_set={1,2,3,4,5}
sub_set={1,2,3}
temp_set={3,2,1}
flag_set={7,8,9}


print(sup_set>sub_set) #  输出为ture
print(sup_set<sub_set) # 输出为false
print(temp_set==sub_set) # 输出为ture

 

8、两个set是否没有交集

res=flag_set.isdisjoint(temp_set)
print(res)
res=temp_set.isdisjoint(sup_set)
print(res)