一 Tuple(元祖)
"""
1.什么是元祖(tuple)
python提供的容器型数据类型，不可变并且有序。(元祖就是不可变的列表)
不可变 - 不支持增删改，只支持查
有序 - 每个元素对应一个确定的下标
除了不可变就是和列表一样的
2.字面量和元素
(元素1, 元素2, 元素3...)
其中的元素可以是任何类型的数据，并且类型可以不一样，同样的元素可以有多个
"""
point = (100, 30)
print(point, type(point)) # (100, 30) <class 'tuple'>
# 注意:
# 1.空的元祖:()
tuple1 = ()
print(type(tuple1)) # <class 'tuple'>
# 2.只有一个元素的元祖
tuple2 = (100,)
print(tuple2, type(tuple2)) # (100,) <class 'tuple'>
# 3.可以直接将多个元素用逗号隔开，不加小括号表示也是一个元祖
tuple3 = 1, 2, 3
print(tuple3, type(tuple3)) # (1, 2, 3) <class 'tuple'>
3.元祖获取元素和列表是一样
tuple4 = ('成都', '达州', '绵阳', '南充', '广元')
# 获取单个元素
print(tuple4[1], tuple4[-1]) # 达州 广元
# 获取部分元素
print(tuple4[0:3]) # ('成都', '达州', '绵阳')元祖切片成为新的元祖
print(tuple4[::-1])
# 遍历
for city in tuple4:
print(city)
for index in range(len(tuple4)):
print(tuple4[index])
补充:特殊的获取方式
1.变量1, 变量2... = 元祖 -- 用前面的变量依次获取元祖元素的值。(要求前面变量的个数和元祖元素的个数一直)
point = (100, 200, 10)
x, y, z = point # x, y, z = (100, 200, 10) <==> x, y, z = 100, 200, 10
print(x, y, z) # 100 200 10
2.变量1, 变量2 = 元祖 -- 通过带的变量获取元祖中的剩余部分;
注意:这个结构中带的变量只能有一个，不带的变量可以有多个
name, *scores = ('小明', 100, 89, 67, 99)
print(name, scores) # 小明 [100, 89, 67, 99]
name, num, *scores = ('小明', 100, 89, 67, 99)
print(name, num, scores) # 小明 100 [89, 67, 99]
*info, num1, num2 = ('小明', 100, 89, 67, 99)
print(info, num1, num2) # ['小明', 100, 89] 67 99
补充: *的用法
1.取元祖和列表中的数据
nums = (1, 2, 3)
print(*nums) # print(1, 2, 3)= 1 2 3
num2 = [11, 22, 33]
print(*num2) # 11 22 33
2.取字典中的元素
dict1 = {'a':1, 'b': 2}
print(**dict1) # 会报错在函数里面才有用，后面讲
"""
4.相关运算(和列表一样)
+, *
in / not in
len(), max(), min(), sum(), tuple(类型转换)
"""
tuple1 = (1, 2, 3)
tuple2 = ('aa', 'bb')
print(tuple1 + tuple2) # (1, 2, 3, 'aa', 'bb')
print(tuple1 * 3) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
print('aaa' in tuple2) # False
"""
5.排序
sorted(序列) - 对序列中的元素排序，产生一个新的列表(不管是什么序列，排完最后都是列表)
注意: 列表.sort() -- 修改原列表中元素的顺序; sorted(列表) --产生一个新的列表
"""
nums = (1, 34, 89, 9)
print(sorted(nums, reverse=True)) # 从大到小 [89, 34, 9, 1]
print(sorted('acbdfeh')) # ['a', 'b', 'c', 'd', 'e', 'f', 'h']
join的使用
"""
字符串.join(序列) - 将序列中的元素取出，用指定的字符串连接在一起。要求序列中的元素必须是字符串
"""
new_str = '*'.join('abc')
print(new_str) # a*b*c
new_str1 = ''.join(['ac', 'bd', 'feh'])
print(new_str1, type(new_str1)) # acbdfeh <class 'str'>
二dict(字典)
"""
1.什么是字典(dict)
python提供的容器型数据类型，可变并且无序
可变 - 支持元素的增删改
无序 - 不支持下标操作
2.字面量和元素
用大括号括起来，里面有多个键值对，每个键值对用逗号隔开。键值对就是字典的元素。
{key1:value1, key2:value2, key3:value3...}
键值对 - 键/key:值/value(键值对)；键值对必须成对出现, 而且脱离字典单独出现没有意义
键/key - 必须是不可变的，而且是唯一的。实际一般将字符串作为键
值/value - 可以是任何类型的数据
注意: 字典存储数据，实质是通过值来存储的。key是值对应的标签和获取值
"""
# dict1 = {'a': 100, 10: 200, (1, 2): 'abc', [10, 20]: 'hello'} # 列表不行因为可变，会报错
# print(dict1) # [10, 20]: 'hello' TypeError: unhashable type: 'list 列表不行因为可变，会报错
dict1 = {} # 空字典
dict1 = {'a': 100, 10: 200, (1, 2): 'abc', 'a': 'hello', 'a': [1, 11, 111]}
print(dict1) # {'a': [1, 11, 111], 10: 200, (1, 2): 'abc'} key唯一，不可变
"""
3.什么时候使用字典:多个没有相同意义的数据(需要区分)，就使用字典。例如：保存一个人的不同信息，一辆车的不同信息（通过key来区分）
什么时候用列表：存储的多个数据是相同意义的数据(不需要区分)，就使用列表。例如:保存一个班的学生的信息，保存所有的价格(都是学生，都是价格不需要区分)
"""
# 应用场景，为什么用字典
person = ['小花', 18, 'girl', 160, 90, 89]
person[1]
person[-2] # 不知道上面的到底哪个是体重 还是分数，所以就可以用字典
person = {'name': '小花', 'age': 18, 'sex': 'girl', 'height': 160, 'weight': 90, 'score': 89}
print(person['age']) # 清楚明了
练习:声明一个变量保存一个班的学生信息(4)，每个学生需要保存，姓名，电话，年龄
分析：前面是都是学生所以用列表，后面有不同的相同意义就是字典
all_students = [
{'name': '小唐', 'tel': '13777667267', 'age': 21},
{'name': '小新', 'tel': '17776672267', 'age': 20},
{'name': '小花', 'tel': '19076226767', 'age': 19},
{'name': '小雷', 'tel': '15542766767', 'age': 18}
]
print(all_students[0]) # {'name': '小唐', 'tel': '13777667267', 'age': 21}
三03-dictitem(字典的元素的增删改查)
"""
字典元素的增删改查
1.查(获取值)
注意:字典中的键值对单独拎出来没有任何意义
a.字典[key] - 获取字典中key对应的值（key扮演下标的角色）
注意: 当key不存在的时候，会报错KeyError
"""
car = {'color': '黄色', 'type': '跑车', 'price': '500000'}
print(car['color']) # 黄色
print(car['price']) # 500000
# print(car['speed']) # KeyError: 'speed' 'speed'不存在
"""
b.
字典.get(key) - 获取字典中key对应值;当key不存在的时候不会报错，并且取到一个默认值None
字典.get(key,值1) - 获取字典中key对应值；当key不存在的时候不会报错，并且取到指定的值1
key不确定时用get,确定用字典[key]
"""
print(car.get('type')) # 跑车
print(car.get('speed')) # None
print(car.get('color', '红色')) # 黄色
print(car.get('speed', 0)) # 0 当key不存在的时候不会报错，并且取到指定的值1 0就是值1
"""
c.遍历字典
注意:直接通过for in遍历字典取到的是key
注意:遍历字典的时候，字典的长度不能改变。
如果遍历字典后对字典的操作会改变字典长度，那么就不要遍历字典，而是遍历字典的copy
"""
dict1 = {'a': 100, 'b': 200, 'c': 300}
# 遍历字典取到的是key（推荐使用，因为只需要遍历一次）
for key in dict1:
# 取到key
print(key, end='')
# value
print(dict1[key])
# 遍历字典的values()，获取所有的值
for value in dict1.values():
print(value)
# 它的内部操作
# values = []
# for key in dict1:
# values.append(dict1[key])
# for value in values:
# print(value) # 又多执行一次
# 字典数据小的时候可以用
# 遍历字典的items(),直接获取key和value(不建议使用，因为至少遍历2次，万一数据很大，多CPU消耗更多)
for key, value in dict1.items():
print(key, value)
# 它的内部操作
# items = []
# for key in dict1:
# items.append((key, dict1[key]))
# for key, value in items:
# print(key, value) # 多执行一次
"""
2.增，改
a.语法
字典[key] = 值 - 当key不存在就是添加键值对；当key本身就存在的时候就是修改key对应的值
"""
movie = {'name': '喜羊羊与灰太狼', 'type': '卡通', 'time': 120}
# 添加
movie['score'] = 7.9 # {'name': '喜羊羊与灰太狼', 'type': '卡通', 'time': 120, 'score': 7.9}
print(movie)
# 修改
movie['type'] = '搞笑'
print(movie) # {'name': '喜羊羊与灰太狼', 'type': '搞笑', 'time': 120, 'score': 7.9}
"""
3.删(删除键值对)
a.
del 字典[key] - 删除字典中指定的key对应的键值对
b.
字典.pop(key) - 取出字典中key对应的值
"""
del movie['time']
print(movie) # {'name': '喜羊羊与灰太狼', 'type': '搞笑', 'score': 7.9}
name = movie.pop('name')
print(movie, name) # {'type': '搞笑', 'score': 7.9} 喜羊羊与灰太狼
练习:用一个字典保存一个学生的信息:{'name': '张三', 'age': 30, 'score': 80}
输入需要修改的信息，例如输入:name -> 修改名字... abc -> 提示'没有该信息'
"""
请输入要修改的信息:name
请输入新的名字:李四
{'name': '李四', 'age': 30, 'score': 80}
请输入要修改的信息：age
请输入新的年龄:18
{'name': '张三', 'age': 18, 'score': 80}
请输入要修改的信息:abc
没有该信息
"""
student = {'name': '张三', 'age': 30, 'score': 80}
message = input('请输入要修改的信息:')
if student.get(message):
print('可以修改')
if message == 'name':
new_name = input('请输入新的名字:')
student['name'] = new_name
elif message == 'age':
new_age = int(input('请输入新的年龄:'))
student['age'] = new_age
else:
new_score = input('请输入新的分数:')
student['score'] = new_score
print(student)
else:
print('没有该信息！')
四，dictMethod(字典相关方法)
"""
1.比较运算
==, !=
注意: 判断两个字典是否相等，只看键值对是否一样，不管键值对的顺序
字典不支持>和<符号
"""
# print({'a': 1}) + {'aa': 11} # TypeError: unsupported operand type(s) for +: 'NoneType' and 'dict'不支持+ *运算
print({'a': 11, 'b': 22} == {'b': 22, 'a': 11}) # True 说明字典是无序的
"""
- in / not in
key in 字典 --- 判断字典中指定的key是否存在
key not in 字典 --- 判断字典中指定的key是否不存在
"""
dict1 = {'a': 1, 'b': 2, 'c': 3}
print('a' in dict1) # True
print(1 in dict1) # False
"""
3.len(), max(), min(),
dict(数据) - 数据要求是序列，并且序列中的元素都是有两个元素的子序列
"""
获取字典中键值对的个数
print(len(dict1)) # 3
获取字典中key的最大值/最小值
print(max(dict1), min(dict1)) # c a
# print(sum(dict1)) # TypeError: unsupported operand type(s) for +: 'int' and 'str'
# 说明不支持求和
将列表转换成字典
print(dict([(1, 2), ('a', 'b')])) # {1: 2, 'a': 'b'} 只有两个元素才可以，多一个少一个都不行(不然会报错)
字典转列表/元祖/集合都是将字典中的key取出来作为列表/元祖/集合的元素
dict2 = {'name': '小花', 'color': 'black', 'height': 170}
# 字典转列表/元祖/集合都是将字典中的key取出来作为列表/元祖/集合的元素
print(list(dict2)) # ['name', 'color', 'height']
"""
4.相关方法
"""
1.字典.clear() - 清空字典
"""
注意： 清空容器推荐使用clear操作，而不是重新赋一个空的容器
"""
dict2 = {'name': '小花', 'color': 'black', 'height': 170}
dict2.clear() # 建议使用，它只是把容器空间里面的东西扔掉
print(dict2) # {}
只有容器本身不存在的时候，可以用:
dict2 = {} # 把容器毁掉，然后再开辟一个相同空间的容器
直接赋值，修改其中一个的元素，会影响另外一个
dict2 = {'name': '小花', 'color': 'black', 'height': 170}
dict3 = dict2
print(dict3)
dict3['name'] = '小明'
print(dict3)
print(dict2)
拷贝赋值，会产生新的地址，复制后相互不影响
dict2 = {'name': '小花', 'color': 'black', 'height': 170}
dict4 = dict2.copy()
print(dict4)
del dict4['color']
print(dict4)
print(dict2)
3.字典.fromkeys(序列, 值) -- 以序列中所有的元素作为key，指定的值作为value创建一个新的字典
new_dict = dict.fromkeys('abc', 100)
print(new_dict) # {'a': 100, 'b': 100, 'c': 100}
new_dict = dict.fromkeys(['name', 'age', 'tel'], 0)
print(new_dict) # {'name': 0, 'age': 0, 'tel': 0}
"""
字典.keys() - 将字典所有的key取出产生一个新的序列
字典.values() - 将字典所有的value取出产生一个新的序列
字典.items() - 将字典所有的key和value取出产生一个新的序列
"""
dict2 = {'name': '小花', 'color': 'black', 'height': 170}
print(dict2.keys(), dict2.values(), dict2.items())
5.字典.setdefault(key, value=None)
"""
字典.setdefault(key) - 当key不存在的时候，添加键值对key：None
字典.setdefault(key, value) - 当key不存在的时候，添加键值对key：value
注意:这个操作当key存在的时候，不会修改
"""
dict2 = {'name': '小花', 'color': 'black', 'height': 170}
dict2.setdefault('name2', '小胡') # {'name': '小花', 'color': 'black', 'height': 170, 'name2': '小胡'}
dict2.setdefault('sex') # {'name': '小花', 'color': 'black', 'height': 170, 'name2': '小胡', 'sex': None}
print(dict2)
6.字典1.update(字典) - 使用字典2中的键值对取更新字典1；
如果字典2中的key，字典1中本身存在就是修改，不存在就添加
dict2 = {'name': '小花', 'color': 'black', 'height': 170}
dict2.update({'height': 180, 'age': 18})
print(dict2) # {'name': '小花', 'color': 'black', 'height': 180, 'age': 18}
dict2.update([('a', 100), ('age', 30)])
print(dict2) # {'name': '小花', 'color': 'black', 'height': 180, 'age': 30, 'a': 100}
五，set(集合)
"""
1.什么是集合(set)
可变的，无序的;元素是唯一并且不可变
2.字面量
{元素1, 元素2, 元素3...}
"""
set1 = {1, 23, 'abc'}
print(set1)
# set1 = {1, 23, 'abc', [1, 2]} # TypeError: unhashable type: 'list' 不能是列表
表示空集合
set2 = set()
print(type(set2)) # <class 'set'>
集合自带去重功能
set3 = {1, 2, 1, 2, 2}
print(set3) # {1, 2}
list1 = [1, 2, 1, 2, 2]
list1 = list(set(list1))
print(list1) # [1, 2]
"""
3.增删改查
"""
1.查
集合不能单独的获取单个元素，只能一个一个的遍历
for item in set1:
print(item) # 1, abc, 23
2.增
"""
a.集合.add(元素) - 在集合中添加指定的元素
b.集合.uppdate(序列) - 将序列中的元素添加到集合中
"""
set1 = {1, 38, 90, 8}
set1.add('abc')
print(set1) # {1, 38, 8, 'abc', 90}
set1.update('abc')
print(set1) # {1, 38, 'abc', 8, 'a', 'b', 90, 'c'}
set1.update({'aa': 10, 'bb': 20})
print(set1)
3.删
"""
集合.remove(元素) ---删除集合中指定的元素
"""
set1 = {1, 38, 90, 8}
set1.remove(90)
print(set1) # {8, 1, 38}
"""
4.数学集合运算
交集(&):获取两个集合公共的元素产生一个新的集合
并集(|):将两个集合中的元素合并在一起产生一个新的集合
差集(-):集合1 - 集合2：去掉集合1中包含集合2的部分，剩下的部分产生一个新的集合
补集(^):将两个集合合并在一起，去掉公共部分，剩下的部分产生一个新的集合
子集的判断:集合1>集合2 -> 判断集合1中是否包含集合2， 集合1<集合2 - 判断集合1中是否包含集合2
"""
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 9}
# 交集
print(set1 & set2) # {4, 5, 6}
# 并集
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# 差集
print(set1 - set2) # {1, 2, 3}
# 补集
print(set1 ^ set2) # {1, 2, 3, 7, 8, 9}
print({1, 2, 3, 9, 18} > {1, 2, 3, 0}) # False
print({1, 2, 3, 9, 18} > {1, 2, 3, }) # True
print({1, 2, 3} > {1, 2, 3}) # False
print({1, 2, 3} >= {1, 2, 3}) # True
