一、元组

　　定义：t1 = (1, 2) # t1 = tuple((1,2))

　　特点：有序存储、可存放多个数据、不可变(内部可以包含可变对象，可变对象已久可变)

　　应用场景：将不允许操作的列表可以转化为元组，将允许操作的元组转化为列表

　　1.元组的定义

　　　　t1 = () # t1 = tuple()

　　　　print(t1,type(t1)) # () <class 'tuple'>

　　　1.1 tuple() # 参数为for可以循环的对象(可迭代对象)
　　　例如：t2 = tuple("123")
　　　　　　print(t2, type(t2)) # ('1', '2', '3') <class 'tuple'>
　　　　　　t3 = tuple([1, 2, 3])
　　　　　　print(t3, type(t3)) # (1, 2, 3) <class 'tuple'>

　　　　　　t4 = tuple((7, 8, 9))

　　　　　　print(t4, type(t4)) # (7, 8, 9) <class 'tuple'>

　　　1.2 定义一个只有一个元素的元组

　　　　　　t1 = tuple(1, )

　　　　　　t1 = tuple([1])

　　2.元组的操作　　　　

　　　　1.索引取值
　　　　t = (1, 2, 3, 2, 3, 2)
　　　　print(t[1])
　　　　print(t[-2])

　　　　2.切片
　　　　nt = t[:-1:]

　　　　3.长度（item元素个数）
　　　　print(len(t))

　　　　4.元组内置方法
　　　　print(t.count(2)) # 该数据集合可以存放相同数据
　　　　print(t.index(2, 0, 3))

二、字典

　　定义：d1 = {'a': 10, 'b': 20} # d1 = dict({'a': 10, 'b': 20})

　　特点：无序，存放多个值，可变 => 通过key取值

　　1.声明

　　　　dict的key：可以为所以不可变类型：int float tuple str bool None， 一般就采用字符串
　　　　dict的value：可以为所以数据类型
　　　　key具有唯一性（重复会覆盖旧值），value可以重复

　　2.字典的增删改查

　　　　字典无序存储数据，无索引与切片，用key来取值

　　　　2.1 增、改

　　　　　　d1[key] = value: key存在就是改，不存在就是增

　　　　　　update({'a': 100, 'c': 300}): key有更新，无新增

　　　　2.2 查　　

　　　　　　d1[key]: 取，如果key不存在就报错，所以用get(key, defalut)

　　　　2.3 删

　　　　　　pop(key): 根据key删且返回对应value

　　3.get取值

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

　　4.复制

　　　　newDic = dic.copy()

　　　　print(newDic)

　　　　浅copy：只做第一层copy，内部的成员地址还是原来的地址

　　5.随机删除

　　　　dic.popitem()

　　　　返回值是(key,value)

　　6.定义一个空字典

　　　　第一个参数：keys：list|tuple|str，第二个参数：统一的默认value

　　　　d10 = {}.fromkeys(['a', 'b', 'c'], '')
　　　　print(d10) # {'a': '', 'b': '', 'c': ''}

　　7.

　　　　key存在，不操作，不存在设置key=default 

　　　　dic.setDefault(key, default)

三、集合set

　　1.定义

　　　　s1 = set() # {}代表空字典，用set()来创建空集合

　　　s2 = set({1, 2, 3})　

　　2.重点：数据具有唯一性
　　　　1.单列数据集合：str，list，tuple，set 双列：dict
　　　　2.无序存储：无key无index，无法取值
　　　　3.可变数据类型，内部可以存放任意类型数据，但数据具有唯一性

　　3.内置方法与使用 - 集合间的运算 （& | ^ - > < ==）

　　　 p_set = {'a', 'b', 'c', 'egon'}

　　　 l_set = {'x', 'y', 'z', 'egon'}

　　　3.1交集 &
　　　　res = p_set & l_set
　　　　print(res)
　　　　res = p_set.intersection(l_set)
　　　　print(res) # {'egon'}

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

　　 3.3差集
　　　　res = p_set - l_set
　　　　print(res) # {'a', 'b', 'c'}
　　　　res = l_set.difference(p_set)
　　　　print(res) # {'x', 'z', 'y'}

　　 3.4对称差集
　　　　res = p_set ^ l_set
　　　　print(res)
　　　　res = p_set.symmetric_difference(l_set)
　　　　print(res) # {'y', 'a', 'b', 'x', 'z', 'c'}

　　3.5 增、删

　　　　1.添加

　　　　s = set()
　　　　s.add('abc')
　　　　s.add('xyz')
　　　　2.删

　　　　 2.1 res = s.pop() # 随机删除一个ele元素

　　　　 2.2 if 'xyz' in s:

　　　　　　 　　s.remove('xyz') # 有ele删除，无ele抛异常

　　4.了解

　　　　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) # True

　　　　print(sup_set < sub_set) # False
　　　　print(temp_set == sub_set) # True
　　　　# 两个set是否没有交集
　　　　res = flag_set.isdisjoint(temp_set) # True