一、元组
1.什么是元组
格式：tuple = (元素1， 元素2， ……, 元素n)
tuple = 元素1, 元素2, ……, 元素n
注意：只有一个元素时， 元素后加逗号
singel_tuple = (元素1,)
singel_tuple = 元素1,
空元组，
empty_tuple = ()
使用（）将多个元素括起来，多个元素之间用逗号隔开
a.容器，可以同时存储多个数据，不可变的，有序的
不可变 ---> 不能增删改
有序 ---> 可以通过下标获取元素b.元素,可以是任何类型的数据
tuple1 = (1, 'yue', True, [1, 2], lambda s:s*2)
tuple2 = 1, 2, 3
tuple3 = 1,
print(tuple1, tuple2, tuple3, sep = "\n")
注意：1.如果元组的元素只有一个的时候，必须在元素的后面加逗号
tuple2 = (100)
print(type(tuple2)) #
tuple2 = (100,)
print(type(tuple2)) #
注意： 2.多个数据直接用逗号隔开，表示的也是一个元组
tuple2 = 10, 20, 'abc'
print(tuple2, type(tuple2)) # (10, 20, 'abc')
2.元素的查
元组的元素不支持增删改
列表获取元素的方式，元组都支持：元组[下标]，元组[:],元组[::]
index[]
tuple2 = ('星期一', '星期二', '星期三', '星期四', '星期五')
print(tuple2[1])
print(tuple2[2:])
print(tuple2[::-1])
for item in tuple2:
print(item)
index = 0
while index < len(tuple2):
print(tuple2[index])
index += 1
补充：获取部分元素
可以通过相同的变量个数，来一一获取元组中的元素
x, y = (10, 20)
print(x, y)
应用：交换两个数的值
a = 100
b = 200
tuple6 = (a, b) # 过程简写 a, b = b, a 或 a, b =(b, a)
b, a = tuple6
print(a, b)
方法二：
可以通过在变量前加*来获取部分元素
tuple2 = ('小明', 90, 89, 67, 100)
name, *score = tuple2
print(name, score) # 小明 [90, 89, 67, 100]
tuple2 = (90, 89, 67, 100, '小明')
*score, name = tuple2
print(score, name) # [90, 89, 67, 100] 小明
list1 = ['boy', 15300022673, 90, 89, 67, 100, '小明']
sex, tel, *score, name = list1
print(sex, score, name) # boy [90, 89, 67, 100] 小明
可以通过在列表或者元组前加*，来展开列表中的元素
tuple3 = (1, 2, 3, 4)
print(*tuple3) # 1 2 3 4
list1 = ['abc', 100, 200]
print(*list1) # abc 100 200
3.元组的运算
+，*，==，is, in, not in ---> 和列表一样
print((1, 2, 3) + ('a', 'b', 'c')) # (1, 2, 3, 'a', 'b', 'c')
print((1,2) * 3) # (1, 2, 1, 2, 1, 2)
4.len(), max(), min()
tuple3 = 10, 230, 100, 78, 34
print(len(tuple3)) # 5
print(max(tuple3)) # 230
print(min(tuple3)) # 10
5.tuple()
所有的序列都可以转换成元组，注意，字典只能将key值作为元组元素
print(tuple('abcd')) # ('a', 'b', 'c', 'd')
print(tuple([1, 223, 90])) # (1, 223, 90)
print(tuple(range(5))) # (0, 1, 2, 3, 4)
print(tuple({'a': 100, 'b': 200})) # ('a', 'b')
6.sorted()
可以通过sorted()方法，对元组进行排序，产生一个新的列表
tuple3 = 10, 230, 100, 78, 34
new = sorted(tuple3)
print(new, tuple3) # [10, 34, 78, 100, 230] (10, 230, 100, 78, 34)
二、认识字典
什么时候用容器类型的数据？ ---> 需要同时保持多个数据的时候
什么时候用列表？ ---> 保存的多个数据是同一类的数据（不需要区分）
什么时候用字典? ---> 保存的多个数据是不同类的数据（需要区分）
1.什么是字典(dict)
字典是一个容器类的数据类型，可以用来存储多个数据（以键值对的形式存储）
{key1: value1, key2: value2, ……}
可变 ---> 可以增删改
无序 ---> 不能通过下标获取值
键（key）: 用来定位值的，要求只能是不可变的数据类型（数字，字符串，元组……）,是唯一的
值（value):存储的数据，可以是任何类型的数据
person = {'name': 'yuxiaoyu', 'age': 28, 'tel':'173****0924'}
dict1 = {1: 2, 22: 33}
# dict2 = {[1, 2]: 2} # TypeError: unhashable type: 'list'
dict2 = {(1, 2): 22}
dict3 = {'name': 'yuyu', 'name': 'haha'}
print(dict3) # {'name': 'haha'}如果键不唯一，只取一个
三、字典的增删改查
1.查（获取键值对的value)
获取字典的值，必须通过key来获取
- a.字典[key] ---> 获取key对应的值
注意：key值必须是存在的，否则会报KeyError
student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'gender':'male'}
print(student['name'])
print(student['gender'])
# print((student['score'])) # KeyError: 'score'
- b.字典.get(key) ---> 通过key获取值
注意：key值不存在的时候不会报错，结果是None
print(student.get('age')) # 30
print(student.get('score')) # None
确定key一定存在就是使用[]语法，key可能不存在的时候使用get语法
- c.直接遍历字典（推荐使用）
通过for-in遍历字典拿到的是key值
student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'gender':'male'}
for x in student:
print(x) # 打印student的key
- d.其他遍历方式（了解）
直接遍历拿到值
（将字典先遍历一遍，将字典里面的值取出，放到一个容器里面，浪费CPU资源）
for value in student.values():
print(value) # 打印student的值
遍历拿到key和value
for key, value in student.items():
print(key, value) # 打印student的键和值
print(student.items()) # dict_items([('name', '小明'), ('age', 30), ('study_id', 'py001'), ('gender', 'male')])
(在上面的基础上，items还要进行类型的转换，消耗CPU资源）
2.增（添加键值对）
字典[key] = 值 （key不存在）
car = {}
car['color'] = 'yellow'
print(car) # {'color': 'yellow'}
car['price'] = 300000
print(car) # {'color': 'yellow', 'price': 300000}
3.修改（修改值）
字典[key] = 新值（key存在）
car['color'] = 'red'
print(car) # {'color': 'red', 'price': 300000}
4.删（删除键值对）
- a. del 字典[key] ---> 通过key删除键值对
student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'gender':'male'}
del student['age']
print(student) # {'name': '小明', 'study_id': 'py001', 'gender': 'male'}
- b. pop(key) ---> 取出key对应的值（实质还是删除key对应的键值对）
name = student.pop('name')
print(student, name) # {'study_id': 'py001', 'gender': 'male'} 小明
四、字典的相关操作
1. 字典相关运算
== : 判断两个字典的值是否相等
is : 判断两个字典的地址是否相等
in 和 not in : key in 字典 / key not in 字典 （看键是否在字典）
print({'a': 100, 'b': 200} == {'b': 200, 'a': 100}) # True
print({'a': 100, 'b': 200} is {'b': 200, 'a': 100}) # False
print('a' in {'a': 100, 'b': 200}) # True
print(100 in {'a': 100, 'b': 200}) # False
2.字典相关的函数和方法
- 1.len(字典) ---> 获取键值对的个数
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(len(dict1))
- 2.字典.clear() ---> 清空字典
dict1.clear()
print(dict1)
- 3.字典.copy() ---> 将字典中的键值对复制一份，产生一个新的字典
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict2 = dict1.copy()
print(dict2) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(dict1 is dict2) # False
- 4.dict.fromkeys(序列,值) (静态方法）
---> 创建一个字典，将序列中的每个元素作为key,值作为value
dict3 = dict.fromkeys('abcd', 100)
print(dict3) # {'a': 100, 'b': 100, 'c': 100, 'd': 100}
- 5.字典.get(key) --> key不存在取None
字典.get(key,默认值) --> key不存在取默认值
student = {}
print(student.get('name')) # None
print(student.get('name', '无名')) # 无名
- 6.字典.values() ---> 返回所有值对应的序列
字典.keys() ---> 返回所有键对应的序列
字典.items() ---> 将键值对转换成元组，作为一个序列的元素
注意：返回的都不是列表，是其他类型的序列
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(dict1.items(),type(dict1.items())) # dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
items = list(dict1.items())
print(items,type(items)) # [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
- 7.字典.setdefault(key) ---> 添加键值对，键是key,值是None
字典.setdefault(key,值) ---> 添加键值对，键是key，值是value
注意：key存在的时候，对字典不会有任何操作（不会修改key对应的值）
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict1.setdefault('aa')
print(dict1) # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'aa': None}
dict1.setdefault('bb', 100)
print(dict1) # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'aa': None, 'bb': 100}
- 8.字典1.update(字典2) ---> 使用字典2中的键值对取更新字典1(已经存在的key就更新，不存在的就添加)
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 200, 'c': 100}
dict1.update(dict2)
print(dict1) # {'a': 1, 'b': 200, 'c': 100}
五、集合
1.什么是集合（set)
容器，可以同时存储多个数据，可变的，无序的，元素是唯一的
{元素1, 元素2, ……}
可变 --> 增删改
无序 --> 不能通过下标获取元素
唯一 --> 自带去重的功能
元素只能是不可变的数据
set1 = {10, 'abc', (10, 200)}
# set2 = {[1, 2]} # TypeError: unhashable type: 'list'
# set3 = {{'a': 1}} # TypeError: unhashable type: 'dict'
set4 = {} # 这是一个空的字典
2.集合的增删改查
a.查（获取元素）
集合不能单独获取一个元素，也不能切片，只能通过for-in来遍历
for x in set1:
print(x)
# abc
# (10, 200)
# 10
b.增
- 集合.add(元素) --> 在集合中添加一个元素
set1 = {1, 2, 3}
set1.add(4)
print(set1) # {1, 2, 3, 4}
- 集合.update(序列) --> 将序列中的元素添加到集合中（序列为字典时，只添加键到集合中）
set1.update({'a', 'b'})
print(set1) # {1, 2, 3, 4, 'a', 'b'}
set1.update('fsdf1231')
print(set1) # {1, 2, 3, 4, '2', '3', 's', 'd', '1', 'b', 'f', 'a'}
set2 = {1, 2, 3}
set2.update([4, 5, 6])
print(set2) # {1, 2, 3, 4, 5, 6}
set2.update({'a': 7, 'b': 8, 'c': 9})
print(set2) # {1, 2, 3, 4, 5, 6, 'c', 'b', 'a'}
3.删（删除元素）
- 集合.remove(元素) ---> 删除指定的元素
set2 = {1, 2, 3}
set2.remove(1)
print(set2) # {2, 3}
4.改（集合不能改）
六、集合相关的数学运算
集合相关的运算：是否包含，求交集、并集、差集、补集
1.包含
集合1 >= 集合2 --> 判断集合1中是否包含集合2
集合2 <= 集合2 --> 判断集合2中是否包含集合1
set1 = {1 ,2, 3, 4, 5}
set2 = {3, 4, 5}
print(set1 >= set2) # True
set1 = {1 ,2, 3, 4, 5, 10}
set2 = {3, 4, 5, 6}
print(set1 >= set2) # False
2.交集 &
& ：求两个集合公共的部分
set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 & set2) # {1, 3, 5}
3.求并集
| --> 求两个集合的和
set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 | set2) # {1, 2, 3, 4, 5, 7, 9}
4.求差集
集合1 - 集合2 --> 求集合1中除了集合2以外的部分
set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 - set2) # {2, 4}
5.求补集
集合1 ^ 集合2 --> 求两个集合除了公共部分以外的部分
set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 ^ set2) # {2, 4, 7, 9}
七、类型转换
1.整型
int()
浮点数、布尔、部分字符串可以转换成整型
只有去掉引号后本身就是一个整数的字符串才能转换成整型
print(int('34')) # 34
print(int('+34')) # 34
print(int('-34')) # -34
# print(int('34.5')) # ValueError: invalid literal for int() with base 10: '34.5'
2.浮点数
float()
整数，布尔，部分字符串可以转换成浮点数
去掉引号，本身就是一个数字的字符串才能转换成浮点数
print(float(100)) # 100.0
print(float(True)) # 1.0
print(float('34.90')) # 34.9
print(float('100')) # 100.0
3.布尔
bool()
所有的数据都可以转换成布尔值，
为空为0的值转换成False,其他的数据都转换成True
num = 230
if num % 2:
print('是奇数')
else:
print('是偶数')
4.字符串
str()
所有的数据都可以转换成字符串
数据转换成字符串，就是在数据的最外面加引号
print(str(100)) # 00
print([str(True)]) # ['True']
print(str([1, 2, 3, 4])) # [1, 2, 3, 4]
print(str({'a': 1, 'b': 2})) # {'a': 1, 'b': 2}
print(str(lambda x:x*2)) # at 0x0000000002381E18>
print(len(str([1, 2, 3, 4]))) # 12
5.列表
list()
序列才能转换成列表
将序列中的元素作为列表的元素(字典转换成列表，是将字典的key转换成列表的元素)
print(list('abcd')) # ['a', 'b', 'c', 'd']
print(list((23, 45, 'ac'))) # [23, 45, 'ac']
print(list({'a': 100, 'b': 200})) # ['a', 'b']
print(list({'a': 100, 'b': 200}.items())) # [('a', 100), ('b', 200)]
6.元组
tuple()
只能将序列转换成元组
print(tuple('abcd')) # ('a', 'b', 'c', 'd')
print(tuple({'a': 100, 'b': 200})) # ('a', 'b')
7.字典
dict()
序列的每个元素有两个元素的数据才能转换成字典
list1 = [(1, 2)]
print(dict(list1)) # {1: 2}
tuple1 = ((1, 2), ['a', 10])
print(dict(tuple1)) # {1: 2, 'a': 10}
8.集合
set()
序列可以转换成集合，有去重的功能
print(set([1, 1, 90, 3, 10, 10])) # {10, 1, 90, 3}