一：tuple(元祖)
1.什么是元祖（tuple）
python提供的容器型数据类型，不可变并且有序。（元祖就是不可变的列表）
不可变 - 不支持增删改，只支持查。
有序 - 每个元素对应一个确定的下标。
2.字面量和元素
（元素1， 元素2，元素3……）
元素可以是任何类型的数据，并且类型可以不一样，同样的元素可以有多个。
point = (100, 30)
注意：
1。空的元祖：（）
tuple1 = ()
2.只有一个元素的元祖,元素后面必须要加一个逗号
tuple2 = (1, )
3.直接将多个元素用逗号隔开，不加小括号表示的也是一个元祖
tuple3 = 1, 2, 3
print(type(tuple3))
3.元祖获取元素和列表一样
tuple4 = ('成都','天门','九道','八门')
print(tuple4[1]) #获取单个元祖
print(tuple4[::]) #获取部分元祖
for city in tuple4: #遍历
print(city)
补充：特殊的获取方式
1.变量1 ，变量2…… = 元祖 ---->用前面的变量，依次获取元祖中元素的值。（要求前面变量的个数和元祖的个数一致）
point = (100,200)
x, y = point # x,y = (100,200) ---> x,y = 100,200
2.变量1， *变量2 = 元祖 --通过带 *的变量获取元祖中剩余的部分;
注意：这个结构中，带 *的变量只能有一个，不带 *号的可以有多个。
name,*scores = ('小明', 100,23,76,43)
print(name,scores) #小明 [100, 23, 76, 43]
name, num, *scores = ('小明', 100,23,76,43)
*info, num = ('小明', 100,23,76,43)
print(info)
name, *num, scores = ('小明', 100,23,76,43)
print(*num)
补充：*的用法
1.取元祖和列表中的数据
num2 = (1, 2, 3)
num3 = [1, 3, 5,8,3]
print(*num2,*num3)
4.相关运算（和列表一样）
+, *, in /not in
len(), max(), min(), sum(), tuple()
5.排序
sorted(序列) --对序列中的元素排序，产生一个新的列表（不管是什么序列，排序后最后都是列表）。
注意：列表。sort() -- 修改原列表中元素的顺序 ; sorted(列表) -- 产生新的列表
nums = (1, 3, 7, 8, 4)
print(sorted(nums, reverse =True)) #从大到小排序
print(nums) #原元祖元素没变
strs = sorted('afqrsafergdfwghdf')
print(str(strs))
print(''.join(strs))
join的使用
字符串。join(序列) -- 将序列中的元素取出，用指定的字符串连接在一起。要求序列中的元素必须是字符串。
str3 = '*'.join(['a','b','c'])
str4 = ''.join(['a','b','c'])
print(str3,str4)
list4 = [1,234,65,2243]
new_list = list4.sort() #结果是None，sort不会产生新的列表
print(list4, new_list)
3.什么时候使用字典：多个没有相同意义的数据（需要区分），就使用字典。例如：保存一个人的不同信息。
什么时候使用列表：存储的多个数据是有相同意义的数据（不需要区分），就使用列表。例如：保存一个班的名字.
二.dict(字典)
1.什么是字典（dict）
python提供的容器型数据类型，可变并且无序
可变 - 支持元素的增删改
无序 - 不支持下标操作
2.字面量和元素
用大括号｛｝括起来，里面有多个键值对，每个键值对用逗号隔开。其中一个键值对就是字典的元素。
{key1:value1, key2:value2 …… }
a. 键值对 - 键：值（键值对）；键值对必须成对出现，而且脱离字典单独出现是没有意义的。
b. 键/key - 必须是不可变的，而且是唯一的。（键一般是字符串类型）
c. 值/value - 可以是任意类型的数据
注意：字典存储数据，实质是通过值来存储的。key是值对应的标签和获取值的方式。
dict1 = {'姓名':100,10:234,(1,2):'asd',10:254} #键有多个只保存一个
print(dict1) #{'姓名': 100, 10: 254, (1, 2): 'asd'}
dict2 = {} #空字典
三：字典元素的增删改查
1.查（获取值）
注意：字典中的键值对单独拎出来没有任何意义
a.字典[key] - 获取字典中key对应的值。
注意：当key不存在的时候，会报错KeyError。
car = {'color': '白色', 'type': '跑车','price':'50万'}
print(car['color']) # 白色
#print(car['cswe']) #KeyError: 'cswe'
b.
- 字典.get(key) - 获取字典中key对应值;当key不存在的时候不会报错，并且取到一个默认值None
- 字典.get(key,值1) -获取字典中key对应值;当key不存在的时候不会报错，并且取到指定的值1.
print(car.get('type'))
print(car.get('csdwsdf')) #None
print(car.get('color','红色'))
print(car.get('村舍模压','0000'))
c.遍历字典
注意：直接通过fot-in遍历字典取到的是key （建议使用）
car = {'color': '白色', 'type': '跑车','price':'50万'}
for key in car:
print(key, end=' ') #遍历字典取到的是key
print(car[key])
遍历字典的values（），获取所有的值
for value in car.values():
print(value)
遍历字典的items(),直接获取key和value（不建议使用）
for key,value in car.items():
print(key,value)
2.增、改
a.
字典[key] = 值 - 当key不存在就是添加键值对，当key存在时就是修改key对应的值
1.修改
car = {'color': '黑色', 'type': '跑车', 'price': '50万'}
car['color'] = '白色'
print(car)
2.增加
car['油耗'] = '10' # 在最后添加
print(car)
3.删（删除键值对）
a. del 字典[key] - 删除字典中指定的key对应的键值对
b. 字典.pop(key) - 取出字典中key对应的值
car = {'color': '黑色', 'type': '跑车', 'price': '50万'}
del car['color']
print(car)
练习：用一字字典保存一个学生的信息：｛'name':'张生'， 'age':30,'score':80｝输入需要修改的信息，例如输入name-->修改名字，，输入没有的，提示没有。
dict1 = {'name':'张生', 'age':30,'score':80}
num = input('请输入你要修改的属性：')
if dict1.get(num):
if num =='name':
new_num = input('请输入新的名字：')
dict1[num] = new_num
elif num == 'age':
new_age = input('请输入新的年龄：')
dict1[num] = new_age
elif num == 'score':
new_score = input('请输入新的体重：')
dict1[num] = new_score
print(dict1)
else:
print('没有该信息！')
四：字典运用方法
1.比较运算
== , !=
注意：判断两个字典是否相等，只看键值对是否一样，不管键值对的顺序。
字典不支持>和<符号。
print({'a':11,'b':22} =={'b':22,'a':11}) #True
2。 in / not in
key in 字典 --判断字典中指定的key是否存在。
key not in 字典 --判断字典中指定的key是否是不存在。
dict2 = {'a':11,'b':22}
print('a' in dict2) #True
print(1 in dict2) #False
3.len(), max(), min(), dict()
dict(数据) -- 数据要求是序列，并且序列中的元素都是有两个元素的子序列
print(len(dict2)) #获取字典中键值对的个数
#获取字典中key的最大值、最小值
print(max(dict2))
print(min(dict2))
将列表或者元祖转成字典
print(dict([(1,2),(7,4)]))
print(dict(((1,2),(7,4))))
字典转列表、元祖、集合都是将字典中的key取出来作为列表、元祖、集合的元素。
dict3 = {'生命':'永恒','力量':'无限',}
print(list(dict3)) #['生命', '力量']
4.相关方法
1。字典.clear() - 清空字典(推荐用这个)
注意：清空窗口推荐使用clear操作，而不是重新赋一个新的容器。
dict = {} #（清空）不推荐用。
dict3 = {'生命':'永恒','力量':'无限',}
print(id(dict3))
dict3.clear()
print(id(dict3))
dict3 = {} # 只有本身不存在的时候，可以使用
print(id(dict3))
#以上三个地址，12是一样的；第三个地址是新的，重新开辟了内存空间。
2. 字典.copy() -复制字典中的元素，产生一个新的字典。
dict5 = {'生命':'永恒','力量':'无限',}
dict6 = dict5 #修改dict6时，dict5也会被改变。
直接赋值，修改其中一个的元素，会影响另外一个。
dict6 = dict5.copy() #copy赋值，会产生新的地址，赋值后想到之间不影响。
3.dict.fromkeys(序列，值) -- 以序列中所有的元素作为key,指定的值作为val创建新的字典。
new_dict = dict.fromkeys('abc',100) #值是一个，写多个将作为一个整体。
print(new_dict) #{'a': 100, 'b': 100, 'c': 100}
new_dict = dict.fromkeys(['asd','were','234'],100)
4.
字典.keys() - 将字典所有的key取出产生一个新的序列。
字典.values() - 将字典所有的values取出产生一个新的序列。
字典.items() - 将字典所有的key和values做为一个元祖取出产生一个新的序列。
dict5 = {'生命':'永恒','力量':'无限',}
5. 字典.setdefault(key, value=None)
字典.setdefault(key) - 当key不存在的时候，添加键值对key:None
字典.setdefault(key, value) - 当key不存在的时候，添加键值key:value
注意：这个操作当key存在的时候，不会修改，
dict5 = {'生命':'永恒','力量':'无限',}
dict5.setdefault('光辉','耀眼')
print(dict5)
dict5.setdefault('命运')
print(dict5)
6.字典1.update(字典2) -- 使用字典2中的键值对去更新字1， 如果字典2中的key,字典1中本身存在就是修改，不存在就添加。
dict5 = {'生命':'永恒','力量':'无限',}
dict5.update({'生命':'长河','智慧':'藏拙'})
print(dict5)
五：集合（set）
1.什么是集合（set）
可变的，无序的；元素是唯一并且不可变。
2.字面量
｛元素1，元素2，元素3……｝
set1 = {1,2,3,'ass'} #
ste2 = {} #这个是空的字典
print(type(ste2))
ste2 = set() #这是空的集合
`集合自带去重功能`
list1 = [1,2,5,2,6,8,1]
list1 = list(set(list1)) #列表转集合，再转成列表
print(list1)
3.增删改查
1.查 （只能通过遍历查找）
集合不能单独的获取单个元素，只能一个一个的遍历for x in set:
2.增
a.集合.add(元素) - 在集合中添加指定的元素
b.集合.update(序列) - 将序列中的元素添加到集合中
set2 = {1,2,5,2,6,8,1}
set2.add('abc')
print(set2)
set2.update('abl') #添加字典时，只是添加了key
print(set2) #每个字符作为一个元素添加，无序的。
3.删
集合.remove(元素) - 删除集合中指定的元素
set1 = {12,34,21,66}
set1.remove(12)
print(set1)
4.数学集合运算
交集（&）：两个集合公共的元素
并集(|)：将两个集合中的元素合并在一起，产生一个新的集合。
差集（-）：集合1 - 集合2：去掉集合1中包含集合2的部分，剩下的产生一个新的集合。
补集（^）：将两个集合合并在一起，去掉公共部分，剩下部分产生一个新的集合。
子集的判断：集合1 > 集合2 --判断集合1中是否包含集合2.
集合1 < 集合2 -- 判断集合2中是否包含集合1.
set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8,9,10}
`交集`
print(set1 & set2) #{4, 5, 6}
`并集`
print(set1 | set2)
`差集`
print(set1 - set2)
`补集`
print(set1 ^ set2)
`子集的判断`
set1 = {4,5,6}
set2 = {4,5,6,7,8,9,10}
print(set1 > set2)
print(set1 < set2)
print({1,2,3} > {1,2,3}) #False 这个集合2不是集合1的子集。
