今天是第八天，给大家分享一下python中的：
元组，字典和集合
一、元组
1.什么是元组（tuple）
元组就是不可变的列表
元组也是容器型数据类型, 将()作为容器的标志，多个元素之间用逗号隔开：(元素1, 元素2, 元素3, 元素4,...)
元组不可变(不支持增删改)；元组是有序的(支持下标操作)
元组中的元素的要求和列表一样
1)空元组: ()
tuple1 = ()
print(type(tuple1))
2)单个元素的元组: (元素)
list1 = [10] # 单个元素的列表
tuple2 = (10)
print(tuple2, type(tuple2)) # 10
tuple3 = (10,)
print(tuple3, type(tuple3)) # (10,)
3)多个元素的元组：
a. 变量 = (元素1, 元素2, 元素3,...)
tuple4 = (100, 200, 300)
print(tuple4, type(tuple4)) # (100, 200, 300)
b. 变量 = 元素1, 元素2, 元素3, ...
tuple5 = 10, 20, 30, 40
print(tuple5, type(tuple5)) # (10, 20, 30, 40)
2. 获取元组中的元素
1)列表获取元素的方式元组都支持
a.获取单个元素
names = '生活大爆炸', '权利的游戏', '吸血鬼日记', '破产姐妹', '兄弟连', '尼基塔'
print(names[-2])
b.切片
print(names[1::2]) # ('权利的游戏', '破产姐妹', '尼基塔')
c.遍历
for x in names:
print(x)
print('=========================')
for index in range(len(names)):
print(names[index])
2) 其他方式(同样适用于列表)
a. 变量1, 变量2, 变量3, ... = 元组
==注意: 在这儿变量的个数要和元组中元素的个数保持一致==
tuple6 = (10, 78, 45)
x, y, z = tuple6
print(x, y, z) # 10 78 45
num1, num2 = 100, 200 # num1, num2 = (100, 200)
b.变量1, 变量2, 变量3, ... = 元组
前面的变量的个数小于元组中元组的个数，并且有且只有一个变量前有*
person = ('余婷', '女', 18, 100, 89, 50)
name, gender, age, *num = person
print(name, gender, age) # 余婷 女 18
print(num) # [100, 89, 50]
*x, y, z = 10, 90, 89, 78, 89
print(y, z) # 78 89
print(x) # [10, 90, 89]
a, b, *c, d, e = 1, 2, 3, 4, 5, 6, 7, 8, 9
print(a, b) # 1 2
print(d, e) # 8 9
print(c) # [3, 4, 5, 6, 7]
补充：*的解包功能
list1 = [10, 20, 30]
print(*list1) # 10 20 30 print(10, 20, 30)
3.列表相关操作全部适用于元素
二、字典
定义一个变量保存一个学生的信息：
stu = ['张三', 30, '男', '10011', 170, 65, 60]
print(stu[1])
print(stu[-1])
stu = {'name': '张三', 'age': 30, 'gender': '男', 'id': '10011', 'height': 170, 'weight': 65, 'score': 60}
print(stu['name'])
print(stu['height'])
0.什么时候使用字典
a.需要同时保存多个数据
b.多个数据的意义不同（需要做区分）
1.什么字典(dict)
字典是容器型数据类型，将{}作为容器的标志，多个元素用逗号隔开(字典的元素都是键值对): {键1:值1, 键2:值2, 键3:值3,...}
字典是可变的(支持增删改);字典是无序(不支持下标操作)
字典中元素: 键值对
键 - 不可变; 唯一 （一般是字符串）
值 - 任何类型的数据，可以重复
字典在保存数据的时候，真正想要保存的是值，键是用来对值进行区分和说明
空字典
dict1 = {}
dict2 = {2: 23, 'abc': 'hello', (1, 2): 200}
print(dict2)
字典的key不可变
# dict3 = {[1, 2]: 100, 'abc': 200} # 报错
# print(dict3)
dict3 = {'a': 10, 'b': 20, 'a': 100}
print(dict3) # {'a': 100, 'b': 20}
print({'a': 'b', 'c': 'd'} == {'c': 'd', 'a': 'b'}) # True
2. 获取字典的值
1) 获取单个元素对应的值
a. 字典[key] - 获取字典中指定 key 对应的值(如果key不存在会报错)
dog = {'name': '财财', 'age': 3, 'breed': '土狗', 'gender': '母', 'weight': 10}
print(dog['name'])
print(dog['gender'])
# print(dog['height']) # KeyError: 'height'
b.
字典.get(key) - 获取字典中指定 key 对应的值(如果key不存在不会报错，返回 None)
字典.get(key, 默认值) - 获取字典中指定 key 对应的值(如果key不存在，返回 默认值)
print(dog.get('breed'))
print(dog.get('height')) # None
print(dog.get('age', 0)) # 3
print(dog.get('height', 40)) # 40
2）遍历
a. 需要掌握和适用的遍历方法(效率最高)
for 变量 in 字典:
循环体
注意: 变量取到的是字典中所有的key
dog = {'name': '财财', 'age': 3, 'breed': '土狗', 'gender': '母', 'weight': 10}
for x in dog:
print(x, dog[x])
b. 其他两种情况1(知道)
for 变量 in 字典.values():
循环体
变量取到的是字典所有的值
for x in dog.values():
print(x)
c. 其他两种情况2(知道)
for 变量1, 变量2 in 字典.items():
循环体
变量1能取到字典所有的key，变量2取到的是字典所有的值
for x, y in dog.items():
print(x, y)
print(dog.items())
3.字典的增删改
增/改
语法1：
字典[key] = 值
如果 key 存在， 就将 key 对应的值修改成指定的值 (改)
如果 key 不存在，以 'key:值'的形式添加一个键值对(增)
语法2：
字典.setdefault(键, 值) - 添加键值对(不存在修改功能)
movie = {'name': '西游记', 'time': '1978-10-23', 'director': '吴承恩'}
print(movie)
改
movie['time'] = '1989-10-25'
print(movie)
# 增
movie['score'] = 9.0
print(movie)
# 不会修改
movie.setdefault('score', 8.0)
print(movie) # 'score': 9.0
# 可以增加
movie.setdefault('type', '神话')
print(movie)
删
1）del
del 字典[key] - 删除指定key对应的键值对(key不存在会报错)
"""
movie = {'name': '西游记', 'time': '1989-10-25', 'director': '吴承恩', 'score': 9.0, 'type': '神话'}
del movie['director']
print(movie)
2)pop
字典.pop(key) - 取出字典中指定key对应的值,并且返回被取出的值
value = movie.pop('type')
print(movie, value)
字典的相关操作
字典不支持加法和乘法运算
1)比较运算
字典只支持比较相等，不支持比较大小
print({'a': 1, 'b': 2} == {'b': 2, 'a': 1}) # True
2)in 和 not in
数据 in 字典 - 判断字典中是否存在指定的key
数据 not in 字典 - 判断字典中是否不存在指定的key
cat = {'name': '花花', 'age': 2, 'color': '白色'}
print('name' in cat) # True
print('花花' in cat) # False
3)相关函数
a. len(字典) - 统计字典中键值对的个数
print(len(cat)) # 3
b. dict(数据) - 将自定的数据转换成字典
数据的要求：1.是容器型数据类型 2.数据中元素是有且只有两个元素的容器(小容器) 3.小容器中的第一个元素是不可变的
x = [(1, 2), (3, 4), [5, 6]]
dict1 = dict(x)
print(dict1) # {1: 2, 3: 4, 5: 6}
x = ('ab', 'cd', 'xy', ['name', '张三'])
dict2 = dict(x)
print(dict2) # {'a': 'b', 'c': 'd', 'x': 'y', 'name': '张三'}
c.字典装换成其他的数据类型
bool(字典) - 空字典会转换成 False, 其他都是 True
list(字典) - 将字典所有的key作为列表的元素
tuple(字典) - 将字典所有的key作为元组的元素
cat = {'name': '花花', 'age': 2, 'color': '白色'}
print(list(cat)) # ['name', 'age', 'color']
2.相关方法
1) 字典.clear() - 清空字典
cat.clear()
print(cat) # {}
2) 字典.copy() - 复制字典产生一个新的字典并且返回
cat = {'name': '花花', 'age': 2, 'color': '白色'}
cat1 = cat
cat1['name'] = '咪咪'
print(cat) # {'name': '咪咪', 'age': 2, 'color': '白色'}
cat = {'name': '花花', 'age': 2, 'color': '白色'}
cat2 = cat.copy()
cat2['name'] = '咪咪'
print(cat) # {'name': '花花', 'age': 2, 'color': '白色'}
3)dict.fromkeys()
dict.fromkeys(序列) - 创建一个新的字典，字典的key是序列中的元素，值是 None
dict.fromkeys(序列， 值) - 创建一个新的字典，字典的key是序列中的元素，值是指定的值
dict3 = dict.fromkeys('abc')
print(dict3) # {'a': None, 'b': None, 'c': None}
stu = dict.fromkeys(['name', 'age', 'gender', 'tel', 'address', 'score'])
print(stu) # {'name': None, 'age': None, 'gender': None, 'tel': None, 'address': None, 'score': None}
message = ['张三', '李四', '王五']
for name in message:
new_stu = stu.copy()
new_stu['name'] = name
print(new_stu)
stu2 = dict.fromkeys(['name', 'age', 'gender', 'tel', 'address', 'score'], 0)
print(stu2) # {'name': 0, 'age': 0, 'gender': 0, 'tel': 0, 'address': 0, 'score': 0}
4) items, keys, values
字典.keys() - 获取字典所有的key， 返回一个容器（这个容器不是列表）
字典.values() - 获取字典所有的值，返回一个容器（这个容器不是列表）
字典.items() - 获取字典所有的key和值，返回一个容器，容器中的元素是元组，每个元组对应一个键值对 （这个容器不是列表）
cat = {'name': '花花', 'age': 2, 'color': '白色'}
print(cat.keys()) # dict_keys(['name', 'age', 'color'])
print(cat.values()) # dict_values(['花花', 2, '白色'])
print(cat.items()) # dict_items([('name', '花花'), ('age', 2), ('color', '白色')])
5) update
字典.update(序列) - 用序列生产的字典去更新原字典(更新方式: 不存在就添加，存在就修改)
dict4 = {'a': 10, 'b': 20, 'c': 30}
dict4.update({'a': 100, 'd': 40})
print(dict4) # {'a': 100, 'b': 20, 'c': 30, 'd': 40}
三、集合
1.什么是集合(set)
集合是容器型数据类型，将{}作为容器的标志，里面多个元素用逗号隔开: {元素1, 元素2, 元素3, ...}
集合是可变的(支持增删改); 集合是无序的
集合中元素是不可变并且唯一的
空集合
empty = set() # {}是空字典
非空集合
set1 = {1, 23, 34}
set2 = {(1, 2), 3, 4}
# set3 = {[1, 2], 3, 4} # 列表不能作为集合的元素
set4 = {1, 2, 3, 1, 4, 1}
print(set4) # {1, 2, 3, 4}
print({1, 2, 3} == {2, 3, 1}) # True (说明集合无序)
2.集合中元素的增删改查
1) 查
集合没有办法直接获取单个元素，只能遍历
for 变量 in 集合:
循环体
变量取到的就是集合中的每个元素
nums = {23, 34, 90, 89}
for x in nums:
print(x)
2）增
a. 集合.add(元素) - 在集合中添加指定元素
b. 集合.update(序列) - 将序列中的元素全部添加到集合
nums.add(100)
print(nums) # {34, 100, 23, 89, 90}
nums.update('abc')
print(nums) # {34, 100, 'c', 'b', 23, 89, 90, 'a'}
nums = set()
nums.update({'a': 10, 'b': 20})
print(nums) # {'a', 'b'}
3) 删
集合.remove(元素) - 删除集合中指定的元素(元素不存在会报错)
集合.discard(元素) - 删除集合中指定的元素(元素不存在不会报错)
nums = {10, 89, 76, 90, 34}
# nums.remove(10)
nums.discard(10)
print(nums)
# nums.remove(100) # 报错
nums.discard(100) # 不报错
4）改 - 集合无法修改元素
3.数学集合运算
python中的集合支持数学集合运算：&(求交集)、|(求并集)、-(求差集)、对称差集(^)、>/<(判断是否是真子集)
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8, 9}
1) 交集： 求两个集合的公共部分
print(set1 & set2) # {4, 5}
2) 并集：两个集合合并成一个集合
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
3) 差集：集合1 - 集合2 集合1中除了集合2剩余的部分
print(set1 - set2) # {1, 2, 3}
print(set2 - set1) # {8, 9, 6, 7}
4）对称差集：去掉两个集合公共的部分剩下的部分
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8, 9}
5)真子集
# 集合1 > 集合2 - 判断集合2是否是集合1的真子集
# 集合1 < 集合2 - 判断集合1是否是集合2的真子集
print({100, 200, 300, 400} > {10, 20}) # False
print({1, 10, 20} > {10, 20}) # True
print({10, 20} > {10, 20}) # False