元祖类型，字典类型及集合类型

元祖类型
什么是元组：“元组就是一个不可变的列表”
1 用途：存多个值，但是只有读的需求，没有改的需求
    强调：在元素个数相同的情况下，使用元组更加节省空间

2 定义方式
t=(1,2,3,4) #t=tuple((1,2,3,4))

print(id(t),type(t),t)

3 常用操作+内置的方法
优先掌握的操作：
1、按索引取值(正向取+反向取)：只能取
2、切片(顾头不顾尾，步长)
t=(1,2,3,4,5,6)
print(t[1:4])

3、长度
len
4、成员运算in和not in
5、循环
t=('a','b','c','c')
# t[0]=1111
print(t.index('a'))
print(t.count('c'))
补充for循环
goods=['mac','apple','iphone','tesla']
print(enumerate(goods))
for x,y in enumerate(goods): #x,y=[0, 'mac']
    print(x,y)
s='hello'
for x,y in enumerate(s): #0h 1e 2l 3l 4o
    print(x,y)

enumerate('hello') #(0, 'h') (1, 'e') ...
for item in enumerate('hello'):
    print(item)
res=list(enumerate('hello'))
print(res)

二：该类型总结
1 存多个值
2 有序
3 不可变



字典类型
1 用途：以key：value的形式存多个值
    优点：存取都快，每一个值都有对应的key

2 定义方式:{}内以逗号分隔多个元素，格式为key:value，
其中key必须为不可变类型，value可以是任意类型
dic={'x':1,'y':1,'x':1111} #dic=dict({'x':1,'y':1,'x':1111})
print(dic)
下面也是可以操作的
dic=dict(x=1,y=2,z=3)
print(dic)

3 常用操作+内置的方法
优先掌握的操作：
1、按key存取值：可存可取
dic={'name':'egon'}
dic['age']=10
print(dic)
dic['name']='EGON'
print(dic)

dic['name']=dic['name'].upper()
print(dic)

2、长度len
dic={'name':'egon','age':18}
print(len(dic))

3、成员运算in和not in:判断的字典的key

4、删除
dic={'name':'egon','age':18}
del dic['name']
print(dic)
res=dic.pop('name')
print(res)
print(dic)

res=dic.pop('sex',None)
print(res)

5、键keys()，值values()，键值对items()
dic={'name':'egon','age':18}
print(dic.keys())
print(dic.keys())
for x in dic.keys():
    print(x)
print(list(dic.keys())[0])

print(dic.values())

for key in dic.keys():
    print(key)
for value in dic.values():
    print(value)

print(dic.items())
for k,v in dic.items(): #k,v=('name', 'egon')
    print(k,v)

print(type(dic.items()))


4、掌握的操作
dic={'name':'egon','age':18}
print(dic.get('namexxxxxxxxxxx'))
print(dic['namexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'])
print(dic.popitem())

dic.update({'x':1,'age':19})
对与老字典来说，更新指的是，新字典中有而老字典中没有则添加，新有而老有，则覆盖




print({}.fromkeys(list1,None))
print({}.fromkeys(['name','age','sex'],'xxxxxx'))

setdefaul的用处：
1、字典有中有key，则不修改，返回原key对应的原值
dic={'name':'egon','age':18}
res=dic.setdefault('name','EGON')
print('返回值',res)
print(dic)

2、没有对应的key，则添加，返回添加的key对应的value
dic={'age':18}
res=dic.setdefault('name','EGON')
print('返回值',res)
print(dic) #{'age': 18, 'name': 'EGON'}



总结
1、存多个值
2、无序
3、可变

集合类型

stus_linux=['alex','egon','张全蛋','李铁蛋','oldboy']
stus_python=['李二丫','wxx','liudehua','alex','egon']
常规做法：
stus_py_lx=[]
for stu in stus_linux:
    if stu in stus_python:
        stus_py_lx.append(stu)

print(stus_py_lx)

用途
1、 关系运算
2、去重
s1=set('hello')
print(s1)

l=['a','b',1,'a','a']
print(list(set(l)))

想去重还想保证原来的顺序：了解
l = ['a', 'b', 1, 'a', 'a']
l_new=[]
s=set()

for item in l:
    if item not in s:
        s.add(item) #s={'a','b',1}
        l_new.append(item) #l_new=['a','b',1]

定义方式:在{}内用逗号分隔开一个个元素
注意的问题
1、集合内没有重复的元素
2、集合的元素必须是不可变类型

s={1,2,3,4,4,4,4,4,4,4,'a'} #s=set({1,2,3,4,'a'})
print(id(s),type(s),s)

s={[1,2,3],'aa'}

常用操作与内置方法
stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
stus_python={'李二丫','wxx','liudehua','alex','egon'}

既报名linux又报名python的学生：交集
print(stus_linux & stus_python)
print(stus_linux.intersection(stus_python))

所有的学生：并集
print(stus_linux | stus_python)
print(stus_linux.union(stus_python))


只报名linux，没有报名python的：差集
print(stus_linux - stus_python)
print(stus_linux.difference(stus_python))

print(stus_python -  stus_linux)
print(stus_python.difference(stus_linux))

没有同时报名两门课程的学生姓名：交叉补集
print(stus_linux ^ stus_python)
print(stus_linux.symmetric_difference(stus_python))


优先掌握，循环取值
长度len
成员运算in和not in


查看
s1={1,'a','b','c','d'}
for item in s1:
    print(item)

增加
s1={'a','b','c'}
s1.add() # 一次添加一个值
s1.add(4)
print(s1)


s1.update({3,4,5}) #一次添加多个值
print(s1)

删除
s1.discard() ## 当删除的元素不存在的时候，不会报错
s1.discard(4)
print(s1)

s1.remove() # 当删除的元素不存在的时候，报错
s1.remove(4)


s1.pop() #随机取走一个元素
res=s1.pop()
print(res)

了解的方法
s1={1,2,3}
s2={1,2}
s1=s1.difference(s2)
print(s1)
s1.difference_update(s2)
print(s1)

s1.isdisjoint() #如果两个集合没有交集则返回True
s1={1,2,3}
s2={4,5,6}
print(s1.isdisjoint(s2))
print(s2.isdisjoint(s1))

了解的知识点
父集:爹包含儿子
s1={1,2,3}
s2={1,2}
print(s1.issubset(s2))
print(s2.issubset(s1))
print(s1.issuperset(s2))


print(s1 > s2) # 代表s1包含s2，s1是s2父集
print(s2 < s1) # s2是s1子集