Day 8
一、 元组（tuple）
1、python中容器数据类型，不可变且有序。
元组就是不可变的列表
不可变：不支持增删改，可以查
有序：每个元素对应一个确定的下标
2、 字面量和元素
（元素1，元素2，元素3……）
元素可以是任意的数据类型，并且类型可以不一样，同样的元素可以有多个
3、 注意：
a. 空的元组：()
b. 只有一个元素的元组
t = (90,) 逗号必须要
c. 直接将多个元素用逗号隔开，不加小括号也表示是一个元祖
4、 元组获取元素和列表一样
t = (1, 2, 3, 4)
print(t[1], t[-1])
#2 4
变量1，变量2…… = 元组 --- 用前面的变量一次获得元组元素的值。
要去前面变量的个数和元组元素的个数一致
变量1， 变量2 = 元组 --- 通过带的变量获取元组中剩余的部分。
带‘*’的只能有一个，不带的可以多个
t = 1, 2
x, y = t
t = 1, 2, 4
x, *y = t
# * 的用法
print(*t)
#1 2 4
5、 相关运算（和列表一样）
+，*， in， not in， len（），max（），min（），tuple（）
t1 = 1, 23, 4
t2 = 2, 3, 4
print(t1 + t2)
print(t1 * 2)
#(1, 23, 4, 2, 3, 4)
#(1, 23, 4, 1, 23, 4)
6、 排序
sorted（序列） - 对序列中的元素排序，产生一个新的序列
注意：列表.sort() --修改原列表中元素的顺序
sorted.(列表) -- 产生一个新列表
t1 = 1, 13213, 2134, 45
t2 = sorted(t1)
print(t2)
#[1, 45, 2134, 13213]
7、 join的使用
字符串.join(序列) - 将序列中的元素取出，用指定的字符串连接在一起。
要求序列中的元素必须是字符串
new_str = '*'.join('123')
print(new_str)
#1*2*3
二、 字典
1、 字典的意义
python提供的容器型数据类型，可变且无序
可变 - 支持元素的增删改
无序 - 不支持下标操作
2、 字面量和元素
用大括号括起来，里面多个键值对，每个键值对用逗号隔开。键值对就是字典的元素
{key1:value, key2:value2, key3:value3……}
键值对 - key：键，value：值；键值对必须成对出现，而且脱离字典单独出现没有意义。
key ： 必须是不可变且唯一。实际一般将字符串作为key
value： 可以是任意类型的数据
注意：字典存储数据，实质是通过值来存储的。key是值对应的标签和获取值得方式。
3、 使用字典：多个没有相同意义的数据（需要区分），就使用字典。
例如：保存一个人的不同信息，一辆车的不同信息。
使用列表：存储的多个数据是有相同意义的数据（不要去区分），就使用列表。
例如：保存一个班的学生信息，保存所有的价格
练习：声明一个变量，保存一个班的学生信息，每个学生需要保存姓名、电话和年龄
stu_inf = [{'name': 'ashui', 'tel': "123", 'age': '12'},
{'name': 'xiaoming', 'tel': "123", 'age': '12'},
{'name': 'xiaoming', 'tel': "123", 'age': '12'}]
print(stu_inf[0])
# {'name': 'ashui', 'tel': '123', 'age': '12'}
三、 字典元素的增删改查
1、 查（获取值） - 获取字典中key对应值
注意：字典中的键值对单独拎出来没有任何意义
a. 字典[key] -- 获取字典中key对应值
注意：当key 不存在的时候，会报错KeyError
b. 字典.get(key) - 获取字典中key对应值
注意：当key不存在的时候，会取到一个默认值None
字典.get(key,值1) - 获取字典中key对应值
注意：当key不存在的时候，会取到指定的值1
c. 遍历字典
注意：直接通过for-in遍历字典取到的是key
car = {'color': 'yellow', 'type': '跑车', 'price': 123021341}
print(car['color'])
print(car.get('type'))
#yellow
#跑车
# 遍历字典获取key
for x in car:
print(x)
print(car[x])
# 遍历字典获取values
for x in car.values():
print(x)
# 遍历字典的items（），直接获取键对值
for key, value in car.items():
print(key, value)
2、 增、改
字典[key] = 值 -- 当key不存在的时候，就是添加键值对；当key存在的时候，就是修改key对应的值
3、 删（删除键值对）
a. del 字典[key] -- 删除字典中指定的key对应的键值对
b. 字典.pop(key) -- 取出字典中key对应的值
car['qw'] = 'er'
print(car)
del car['qw']
print(car)
print(car.pop('color'))
用一个字典来保存学生的信息{'name': '张三', 'age' : 30, 'score': 80}
输入需要修改的信息，没有就提示该信息不存在
stu_inf = {'name': '张三', 'age': 30, 'score': 80}
s = input('请输入要修改的信息：')
if stu_inf.get(s):
y = input('请输入要修改的内容：')
if s == 'name':
stu_inf['name'] = y
if s == 'age':
stu_inf['age'] = y
if s == 'score':
stu_inf['score'] = y
print(stu_inf)
else:
print('没有此信息')
stu_inf = {'name': '张三', 'age': 30, 'score': 80}
s = input('请输入要修改的信息：')
if stu_inf.get(s):
for x in stu_inf:
if s == x:
x = input('请输入要修改的信息：')
stu_inf[s] = x
print(stu_inf)
else:
print('没有此信息')
四、 字典的方法
1、 比较运算
== ， != ：判断两个字典是否相等，只看键值对是否一样，不管键值对的顺序
字典不支持大于和小于符号
2、 in / not in
key in 字典 --- 判断字典中指定的key是否存在
key in not 字典 --- 判断字典中指定的key是否不存在
3、 len*(),max(),min()
4、字典类型转换
a. 列表转字典 ：dict(数据) - 数据要求是序列，并且序列中的元素都是有两个元素的子序列
b. 元祖或字典转列表，就是将key提取出来。
5、 相关方法
a. 字典.clear(） - 清空字典
b. 字典.copy() - 复制字典中的元素，产生一个新的字典
c. dict.fromkeys(序列,值) - 以序列中所有的元素作为key，
指定的值作为value创建一个新的字典的初始值
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中本身存在就是修改，不存在就添加
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 2, 'a': 1}
print(dict1 == dict2)
print('a' in dict1)
len(dict1)
dict1.clear()
print(dict1)
print(dict2.keys())
new_dict = dict.fromkeys('abc', 100)
print(new_dict)
print(new_dict.setdefault(2))
五、 集合
1、 什么是集合（set）
可变的，无序的；元素是唯一并且不可变
2、 字面量
{元素1，元素2，元素3,……}
set1 = {1, 23, 'a'}
print(set1)
# {1, 'a', 23}
set2 = set() 空集合
集合自带去重功能
3、查增删
a. 查，集合不能单独的获取的单个元素，只能一个一个的遍历
b. 增：集合.add(元素) - 在集合中添加指定的元素
集合.upadte(序列) - 将序列中的元素添加到集合中
c. 删：集合.remove(元素) - 删除集合中指定的元素
set1 = {1, 2, 3, 4, 5, 6}
for i in set1:
print(i)
set1.add('1')
print(set1)
set1.update(['qw', 'er'])
print(set1)
set1.remove(1)
print(set1)
# 1
# 2
# 3
# 4
# 5
# 6
# {1, 2, 3, 4, 5, 6, '1'}
# {1, 2, 3, 4, 5, 6, 'er', 'qw', '1'}
# {2, 3, 4, 5, 6, 'er', 'qw', '1'}
4、 数学集合运算
交集（&）：获取两个集合公共的元素产生一个新的集合
并集（|）：将两个集合中的元素合并在一起产生一个新的集合
差集（-）：集合1 - 集合2 ，去掉集合1中包含集合2中的部分
补集（^）：将两个集合号合并在一起，去掉公共部分，剩下的产生一个新的集合
子集的判断:集合1>集合2 --> 判断集合1中是否包含集合2
集合1<集合2 --> 判断集合2中是否包含集合1
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
print(set1 & set2)
print(set1 | set2)
print(set1 - set2)
print(set1 ^ set2)
print(set1 > set1)
# {3, 4, 5}
# {1, 2, 3, 4, 5, 6, 7}
# {1, 2}
# {1, 2, 6, 7}
# False