一、元组
（一）用途
元组和列表类似，可以按照位置存放多个任意类型的元素，相当于一个不可变的列表，用于记录多个固定不允许修改的值，单纯用于取。
（二）定义
在小括号()内用逗号分隔开多个任意类型的值。
注意：当元组内只有一个元素时，必须加逗号，否则()就只是包含的意思而非定义元组。
t=(111,222,333) # 本质上是t=tupe((111,222,333))
print(type(t)) # <class 'tuple'>
类型转换：
但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型，tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中。
>>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')
（三）常用的操作类型及内置使用方法
1.优先掌握的操作
（1）按照索引取值(正向取+反向取)：只能取
（2）切片(顾头不顾尾，步长)
（3）len() 长度
（4）成员运算in和not in
（5）循环
t = (111, 222, 333)
for i in t:
print(i)
111
222
333
2.需要掌握的操作
（1）index()
查找传入元素正序第一个索引的序列位置
t = (4444, 5555, 111, 222, 111, 111, 333)
print(t.index(111)) # 2
（2）count()
统计集合中某元素个数
（四）该类型总结
1.存值个数
元组可存多个值
2.是否有序
元组是有序的
3.是否可变
元组是不可变的
二、字典
（一）用途
存多个不同属性的值，使用key对应value的形式，key必须是不可变类型，通常是字符串类型，因为字符串类型可以对value起到很好的解释作用。
（二）定义
在{}内用逗号分隔开的一个或多个key:value元素，其中key必须是不可变类型的，而value可以是任意类型。
>>> d=dict() # 创造一个空字典，或者d={}也是直接造一个空字典
{}
>>> d=dict([("name","egon"),["age",18],("gender",male)])
>>> d
{'name': 'egon', 'age': 18, 'gender': male}
>>> d=dict(name="egon",age=18,gender="male")
>>> d
{'name': 'egon', 'age': 18, 'gender': 'male'}
类型转换：
能以 k,v 形式遍历的数据，可以转换成字典格式，字符串不可以转换成字典。
>>> for k, v in ("na", "en"):
... print(k,v)
...
n a
e n
>>> d=dict(("na","en")) # 可以以k,v的形式遍历
>>> d
{'n': 'a', 'e': 'n'}
定义空
d={} # 定义空字典
s='' # 空字符串
l=[] # 空列表
t=() # 空元组，当元组内只有一个元素时，必须加逗号
s=set() # 定义空集合
（三）常用的操作类型及内置使用方法
1.优先掌握的操作
（1）按key存取值：可存可取
d = {'name': 'egon', 'age': 18}
l = [111, 222, 333]
print(d['name']) # 取
print(l[0])
d['gender'] = 'male' # 可以通过不存在的key完成赋值操作来达到为字典添加值的效果如果key原先存在于字典，则会修改对应value的值
print(d)
l[3] = 444 # 列表不行
（2）len() 长度
d={'name':'egon','age':18}
print(len(d)) # 2
（3）成员运算in和not in
注意：判断的是字典的key
d={'name':'egon','age':18}
print("name" in d) # 判断的字典的key
print("egon" in d) # 判断的不是value，结果为False
（4）删除
1)：万能删除法
d={'name':'egon','age':18}
del d['name']
print(d) # {'age': 18}
2):删除-》取走
d={'name':'egon','age':18}
res=d.popitem() # 非随机删除，LIFO，从最后一个开始删除，返回一个删除元素的小元组，但由于字典是无序的，所以可以认为是随机取。
print(res) # ('age', 18)
res=d.pop('name') # 删除指定的key对应的键值对,并返回值
print(res) # "egon"
print(d) # {}
（5）键keys()，值values()，键值对items()
>>> d = {'name': 'egon', 'age': 18, 'name1': 'egon1'}
# 获取字典所有的key
>>> d.keys()
dict_keys(['name', 'age', 'name1'])
# 获取字典所有的value
>>> d.values()
dict_values(['egon', 18, 'egon1'])
# 获取字典所有的键值对
>>> d.items()
dict_items([('name', 'egon'), ('age', 18), ('name1', 'egon1')])
>>>
（6）循环
d={'name':'egon','age':18}
1) 默认遍历的是字典的key
for k in d:
print(k) # name age
2) 只遍历key
for k in d.keys():
print(k) # name age
3) 只遍历value
for v in d.values():
print(v) # name age
4) 遍历key与value
for k,v in d.items(): # k,v=('age', 18)
print(k,v)
2.需要掌握的操作
（1）get()
注意：字典取值建议使用get() 方法，被取的值不存在也不会报错
d = {'name': 'egon', 'age': 18}
print(d.get('name')) # key存在，则获取key对应的value值
print(d.get('name111')) # key不存在不会报错，会返回None
print(d["name111"]) # key不存在时，可以设置默认返回的值
（2）clear()
d = {'name': 'egon', 'age': 18}
d.clear()
print(d) # {}
（3）update()
用新字典更新旧字典，有则修改，无则添加
d = {'name': 'egon', 'age': 18}
d.update(age=19, gender='male')
d.update({'age': 19, "gender": "male"})
print(d) # {'name': 'egon', 'age': 19, 'gender': 'male'}
（4）fromkeys()
快速初始化好一个字典
>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}
（5）setdefault()
# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}
# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不变
{'k1': 111, 'k2': 222}
（四）该类型总结
1.存值个数
字典类型能存多个值
2.是否有序
字典是无序的
3.是否可变
字典是可变的
三、集合
（一）用途
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
（二）定义
"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
"""
s = {1,2,3,4} # 本质 s = set({1,2,3,4})
# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。
# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典
s = set() # 这才是定义空集合
类型转换：
# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}
（三）常用的操作类型及内置使用方法
一般集合常用的操作就是关系运算与去重，其他的操作都是不经常使用。
1.需要掌握的操作
（1）关系运算
我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算
>>> friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们
>>> friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们
# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}
# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'jason', 'egon'}
# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}
# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}
# 5.值是否相等(==)
>>> friends1 == friends2
False
# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False
# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True
（2）去重
集合去重复有局限性
# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序
示例：
>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序
# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)
print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
{'age': 18, 'sex': 'male', 'name': 'lili'},
{'age': 73, 'sex': 'male', 'name': 'jack'},
{'age': 20, 'sex': 'female', 'name': 'tom'}
]
2.了解的操作
（1）循环
集合可以使用for循环取值，但一般不使用。
s1 = {3, 2, 1}
for item in s1:
print(item) # 1 2 3 循环取值
（2）update()
s1 = {3, 2, 1}
print(id(s1)) # 1897107362976
s1.update({3,4,5}) # 接收集合或者任意可以转换成集合的数据
print(s1) # {1, 2, 3, 4, 5} 集合实现了更新
print(id(s1)) # 1897107362976 # id不变，内容改变，是可变类型的数据
（3）clear()
（4）pop()
移除和返回一个任意集合元素，如果集合为空，则报错。
s1 = {3, 2, 1}
res = s1.pop()
print(s1) # {2, 3}
print(res) # 1 值可以返回
（5）remove()
指定删除集合中的一个元素，它必须是集合的成员，否则会报错。
s1 = {3333, "aaa", 222, "bbb", 111}
res = s1.remove(3333)
print(s1) # {'bbb', 111, 'aaa', 222}
print(res) # None 没有返回值
（6）discard()
指定删除集合中的一个元素，不是集合的成员也不会报错。
s1 = {3333, "aaa", 222, "bbb", 111}
res = s1.discard(3333)
print(s1) # {'bbb', 111, 'aaa', 222}
print(res) # None 没有返回值
（7）add()
给集合添加元素，如果元素已存在，也不会报错。
s1 = {3333, "aaa", 222, "bbb", 111}
s1.add(5555)
print(s1) # {'aaa', 3333, 'bbb', 111, 5555, 222}
（8）isdisjoint()
如果两个集合没有共同的元素则返回True
s1 = {1, 2, 3}
s2 = {4, 5}
print(s1.isdisjoint(s2)) # True
（四）该类型总结
1.存值个数
集合类型可以存多个不重复、不可变类型的值
2.是否有序
集合是无序的
3.是否可变
set集合是可变类型