一、tuple 元组
1.什么是元组（tuple）
python提供的容器型数据类型，不可变且有序。（元组就是不可变的列表）
不可变 -----不支持增、删、改。
有序 -----每个
2.字面量和元素
（元素1元素2元素3···）
其中的元素可以是任何类型的数据，并且类型可以不一样，同样的元素可以有多个
特殊元组：
a.空元组：
tuple1 = ()
b.只有一个元素的元组
tuple2 = (100, )
c.直接将多个元素用逗号隔开，不加小括号
tuple3 = 1, 2, 3
3.元组获取元组和列表一样。
获取单个元素：
print(tuple3[0], tuple3[-1])
获取部分元素：
print(tuple3[0 : 1])
print(tuple3[::-1])
遍历：
for i in tuple:
print(tuple[i])
for i in range(len(tuple)):
print(tuple[i])
补充：
a.变量1， 变量2··· -----用前面的变量依次获取元素的值（要求前面的变量个数和元组元素的个数一致）
tuple4 = (100, 200)
x, y = tuple4
print(x, y)
b.变量1， *变量2 = 元组 -----通过带 * 的变量获取元组中剩余的部分；
注意：带 * 的变量只能有一个，不带 * 的可以有多个。
name, *tuple5 = ('阿黄', 100, 50, 80)
*tuple5, name, num1 = ('阿黄', 100, 50, 80)
name, *tuple5, num1, num2 = ('阿黄', 100, 50, 80, 70, 60)
- 的用法：
取元组和列表中的数据
tuple6 = (1, 2, 3)
list1 = [4, 5, 6]
print(tuple, list1)
4.相关运算（和列表一样）
+， *
in / not in
len(), max(), min(), sum(), tuple()
print(tuple1 + tuple2)
print(tuple1 * 3)
print(1 in tuple6)
5.排序
sorted(序列) -----对序列中的元素排序，产生一个新的列表（不管是什么顺序，排完后最后都是列表）
注意：
列表：
列表.sort(); -----修改列表中元素的顺序
sorted(列表); -----产生一个新的列表
nums = (45, 56, 89, 78)
new_nums = sorted(nums, reverse = True)
new_strs = sorted('oiquwdjkfjskd')
print(str(new_strs))
join 的使用：
字符串.join(序列) -----将序列中的元素取出，用指定的字符串链接在一起，要求序列中 的元素必须是字符串
new_str = ''.join(['adc', '123', 'fgh', 'qwe'])
print(new_str, type(new_str))
list2 = [123, 456, 987]
new_list = list2
二、字典
1.什么是字典（dict）
python提供的容器类型，可变并且无序
可变 -----支持增、删、改。
无序 -----不支持下标操作
2.字面量和元素
用大括号括起来，里面有多个键值对，每个键值对用逗号隔开。键值对就是字典的元素。
{key1:value1, key2:value2, key3:value3...}
键值对： 键/key：值/value（键值对）；键值对必须成对出现，并且脱离字典单独出现时，没有任何意义。
键/key -----必须是不可变，而且唯一的。实际一般将字符串作为键。
值/value -----可以是任意类型的数据。
注意：字典存数据，实际是通过值来存储的。key 是值对应的标签和获取值的方式。
'''
dict1 = {'a': 100, 'adc': (1, 2, 3), 10: 200, 'b': [4, 5, 6]}
'''
3.容器类型的选择：
当多个没有相同意义的数据（需要区分），就使用字典。
例如：保存一个人的信息，一辆车的不同信息。
当存储的多个数据是有相同意义时（不需要区分），就使用列表。
例如：保存一个班的学生信息、保存所有的商品价格等。
练习：声明一个变量，来保存一个班的学生信息（ 4 个学生），每个学生需要保存姓名、电话、年龄。
'''
list = [
{'姓名：': '阿黄', '电话：': 15685825775, '年龄：': 18},
{'姓名：': '小白', '电话：': 18685843810, '年龄：': 18},
{'姓名：': '小黑', '电话：': 987654321, '年龄：': 18},
{'姓名：': '萨摩耶', '电话：': 123456789, '年龄：': 18}
]
三、字典的增删改查
1.查（获取值）
注意：字典中的键值对单独拿出来没有任何意义。
a.
字典[key] -----获取字典中 key 对应的值。
注意：当 key 不存在的时候会报错（KeyError）。
car = {'颜色': '黄', '型号': '超跑', '价格': '50W'}
print(car[颜色])
b.
字典.get(key) -----获取字典中 key 的值；当 key 不存在的时候不会报错，并且取到一个默认值None
字典.get(key, 值1) -----获取字典中 key 的值。当 key 不存在的时候不会报错，并且取到指定的值1
print(car.get('颜色'))
print(car.get('颜色', '红色')) # 结果为：黄色
c.遍历字典
注意：直接通过 for - in 遍历字典，取到的是 key 的值。
for x in car: # 取到的为 key
print(x, end = ' ')
print(car[x])
for value in car.value(): # 遍历字典的 value（），获取所有的值
print(x)
for x,value in car.items(): # 遍历字典的 items（），直接获取 key、value（不建议使用）
print(x)
2.增加、修改
a.
字典.[key] = 值 -----当 key 不存在时，就是添加键值对；
当 key 存在的时候，就是修改 key 对应的值。
添加：
movie = {'name:': '', 'type:': '', 'time': '', '价钱': ''}
movie['score'] = 8.1
print(movie)
# 修改：
movie['type'] = '悬疑'
print(movie)
运行效果：
{'name:': '', 'type:': '', 'time': '', '价钱': '', 'score': 8.1}
{'name:': '', 'type:': '', 'time': '', '价钱': '', 'score': 8.1, 'type': '悬疑'}
3.删除（删除键值对）
a.
del 字典[key] -----删除字典中指定的 key 对应的键值对。
b.
字典.pop(key) -----取出字典中 key 对应的值（键值对）。
例如：
del movie['time']
print(movie)
score = movie.pop('score')
print(movie, score)
运行效果：
{'name:': '', 'type:': '', '价钱': '', 'score': 8.1, 'type': '悬疑'}
{'name:': '', 'type:': '', '价钱': '', 'type': '悬疑'} 8.1
练习：用一个字典保存一个学生的信息：{'name': '阿黄', 'age': 19, 'score': '95', }
输入需要修改的信息，例如：输入：name --> 修改名字；age --> 修改年龄；···；adc --> 提示：没有该信息
例如：
student = {'name': '阿黄', 'age': 19, 'score': '95', }
message = input('请输入要修改的信息：')
if student.get(message):
if message == 'name':
new_name = input('请输入新的名字：')
student['name'] = new_name
elif message == 'age':
new_age = input('请输入新的年龄：')
student['age'] = new_age
else:
new_score = input('请输入新的分数：')
student['score'] = new_score
print(student)
else:
print('没有该信息！')
运行效果：
请输入要修改的信息：name
请输入新的名字：dabai
{'name': 'dabai', 'age': 19, 'score': '95'}
四、字典相关的方法
1.比较运算
==，！=
注意：判断两个字典是否相等，只看键值对是否一样，不管键值对的顺序。
字典不支持比较大小（ < 、 > 符号）。
例如：
print({'a': 1, 'b': 2} == {'b': 2, 'a': 1})
运行效果：
True
2.in /not in
key in 字典 -----判断字典中指定的 key 是否存在
key not in字典 -----判断字典中指定的 key 是否不存在
例如：
dict1 = {'a': 1, 'b': 2, 'c': 3}
print('a' in dict1)
print('a' not in dict1)
运行效果：
True
False
3.len(), max(), min()， dict()
dict(数据) -----数据要求是序列，并且序列中的元素都是有两个元素的子序列
例如：
print(len(dict1)) # 获取字典中键值对的个数
print(max(dict1)) # 求出键值对 key 的编码的最大值
print(min(dict1)) # 求出键值对 key 的编码的最小值
print(dict([('a', 1), ('b', 2), ('c', 'adc')]))
# 字典转列表、元组、集合，都是将字典中的 key 取出来，作为列表、元组、集合的元素。
print(list(dict1))
运行效果：
3
c
a
{'a': 1, 'b': 2, 'c': 'adc'}
['a', 'b', 'c']
4.相关方法
a.
字典.clear() -----清空字典
注意：清空容器时，推荐使用 clear 操作，而不是重新赋一个空的容器
例如：
print(id(dict1))
dict1.clear()
print(dict1)
dict1 = {} # 只有容器本身不存在的时候，才用
print(id(dict1))
运行效果：
1723569765472
{}
1723570633032
b.
字典.copy() -----复制字典中的元素，产生一个新的字典。
直接赋值（ == ），修改其中一个的元素，会影响另外一个。
拷贝赋值（.copy()），会产生新的地址，赋值后相互不影响
c.
字典.fromkeys(序列, 值) -----以序列中的所有元素为 key ，指定的值作为 value 创建一个新的字典
例如：
new_dict = dict.fromkeys('adc', 80)
print(new_dict)
运行效果：
{'a': 80, 'd': 80, 'c': 80}
d.
字典.keys() -----将所有的 key 取出，产生一个新的序列。
字典.value() -----将所有的 value 取出，产生一个新的序列。
字典.items() -----将所有的 key 和 value 取出，产生一个新的序列。
e.
字典.setdefault(key, value = None)
字典.setdefault(key) -----当 key 不存在时，添加键值对 key ： None
字典.setdefault(key， value) -----当 key 不存在时，添加键值对 key ： value
注意：当 key 存在时，不会修改。
f.
字典1.update(字典2) ----使用 字典2 里的键值对，更新 字典1 。
（如果 字典2 中的 key ，在 字典1 中不存在，就添加这个键值对，存在就是修改）
五、集合
1.什么是集合（set）
可变、无序、元素是惟一并且不可变的
重复的元素在输出时，只显示一个。
2.字面量：
{元素1, 元素2, 元素3···}
注意：元素不能为列表、元组、字典。
例如：
set1 = {123, 'adc', 654}
print(set1)
set2 = set() # 用这个表示空集合
# 集合自带去重功能
list1 = [1, 2, 3, 3, 3, 4]
list1 = list(set(list1))
print(list1)
运行效果：
{654, 123, 'adc'}
[1, 2, 3, 4]
3.增删改查
a.查
集合不能单独获取单个元素，只能一个一个的遍历
b.增
集合.add(元素) -----在集合中添加指定的元素
集合.update(序列) -----将序列中的所有元素添加到集合中
例如：
set3 = {1, 2, 3}
set3.add('adc')
print(set3)
set3.update({'aoe', 'apc'})
print(set3)
运行效果：
{1, 2, 3, 'adc'}
{1, 2, 3, 'apc', 'adc', 'aoe'}
3.删
集合.remove(元素) -----删除集合中指定的元素
例如：
set3.remove(1)
print(set3)
运行效果：
{2, 3, 'apc', 'adc', 'aoe'}
4.数学集合运算
交集（&）：获取两个集合公共的部分，产生一个新的集合
并集（|）：将两个集合的元素合并在一起，产生一个新的集合
差集（-）：去掉 集合1 里包含 集合2 的部分，剩下的产生一个新的集合（ 集合1 - 集合2 ）
补集（^）：去到两个集合公共的部分，剩下的产生一个新的集合
子集的判断：集合1 > 集合2 -----判断 集合1 中是否包含 集合2
集合1 < 集合2 -----判断 集合2 中是否包含 集合1
集合1 >= 集合2 -----判断 集合1 是否为 集合2 的子集
集合1 <= 集合2 -----判断 集合2 是否为 集合1 的子集
例如：
set4 = {1, 2, 3, 4, 5, 6}
set5 = {4, 5, 6, 7, 8, 9}
print(set4 & set5) # 结果为：{4, 5, 6}
print(set4 | set5) # 结果为：{1, 2 ,3, 4, 5, 6, 7, 8, 9}
print(set4 - set5) # 结果为：{1, 2, 3}
print(set4 ^ set5) # 结果为：{1, 2, 3, 7, 8, 9}
print(set4 > set5) # 结果为：False
运行结果：
{4, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3}
{1, 2, 3, 7, 8, 9}
False