1.recode 列表
特点：
容器， 可以同时存放多个数据，可变，有序。
元素， 可以使任何类型的数据，一个列表可以存放不同类型的数据
元素的增删改查
查： 列表[下标], 列表[:]， 列表[::] 列表.index(元素), 遍历
增： list.append(元素), list.insert(下标， 元素), list.extend(序列)
删： del list / del list[下标] list.remove(元素), list.pop(), list.pop(下标)
改： 列表[下标] = 新值+ * == is in not inlen(), max(), min(), count(), list(), clear(), copy(),
reverse(), sort()……
2. 元组
1. 什么是元组
格式：tuple = (元素1， 元素2， ……, 元素n) tuple = 元素1, 元素2, ……, 元素n
注意：只有一个元素时， 元素后加逗号
singel_tuple = (元素1,)
singel_tuple = 元素1,
空元组，
empty_tuple = ()
a. 容器， 可以存储多个数据，不可变， 有序的
不可变---> 不能增删改
有序的---> 可以通过下标获取元素
b. 元素， 可以是任何类型的数据
tuple1 = (1, [1, 2], "eryang", 3.4, True, range(10), lambda x, y: x*y)
tuple2 = 1, 2, 3
tuple3 = 1,
print(tuple1, tuple2, tuple3, sep = "\n")
2. 元组的查
元组的元素不支持增删改
列表获取元素的方式元组都支持， 元组[:], 元组[下标], 元组[::], index[], 遍历
tuple4 = ("星期一", "星期二", "星期三", "星期四")
print(tuple4[0], tuple4[1:2], tuple4[::-2], sep = "\n")
for item in tuple4:
print(item)
index = 0
while index < len(tuple4):
print(tuple4[index])
index += 1
补充获取部分元素
可以通过相同的变量个数来依次获取元组中的元素
tuple5 = (10, 20, 30)
x, y, z = tuple5
print(x, y, z)
x, y, c = 10, 20, 30
应用：交换两个数的值
a = 100
b = 200
tuple6 = (a, b) # 过程简写 a, b = b, a 或 a, b =(b, a)
b, a = tuple6
print(a, b)
应用：通过在变量前加*来获取部分的元素, 适用于列表
tuple7 = ("eryang", 90, 89, 67, 100)
name, *score = tuple7 # 第一个变量获取第一个元素，后面元素作为列表赋给第二个元素
print(name, score)
tuple8 = ("eryang",18902348712, 90, 89, 67, 100, "boy")
name, tel, *score, sex = tuple8
print(name, tel, score, sex)
应用：通过在列表或者元组前加来展开列表或元组中的元素在一个容器前加相当于把容器砸了，把数据暴露出来
tuple8 = ("eryang",18902348712, 90, 89, 67, 100, "boy")
print(*tuple8)
3. 元组的运算
+ * == is in not in
4. len(), max(), min(), cmp(), index(), tuple()
tuple9 = (1, 2, 3)
print(len(tuple9), max(tuple9), min(tuple9))
5. 可以通过sorted()函数，对元组进行排序，产生一个新的列表
tuple10 = (1, 3, 5, 2, 4)
new = sorted(tuple10)
print(new)
注意： 所有序列都可以转换为元组，字典只能讲key作为元组元素
dict1 = {"a":5, "b":6, "c":7}
x = tuple(dict1)
print(x)
3. 认识字典
什么时候用容器类型的数据？--->需要同时保存多个数据的时候
什么时候用列表？ --->保存的为同一类(代表的意义)数据的时候
什么时候用元组？ --->保存同一类数据(不可变的)
什么时候用字典？ --->保存的多个数据是不同类的数据
1. 什么是字典
字典是容器类的数据类型,可以用来存储多个数据（以键值对方式存储）
格式: dict = {key1:value1, key2:value2……}
可变---> 可以增删改
无序--->不能通过下标获取值
键(key): 用来定位置的，要求只能是不可变的数据类型(数字， 字符串， 元组)唯一的
值(value): 存储的数据，可以是任何类型的数据
person1 = {"name":"eryang", "age":18, "tel":"12345678900"}
print(person1['name'])
4. 字典的增删改查
1. 查(获取value)
获取字典的value都是通过key获取
获取也只能获取单个
语法:确定key存在时，用语法a，不确定是用语法b
a. dict[key]--->获取key对应的值
注意：key值必须是存在的，不然报错
student = {"name": "小明", "age": 18, "study_id": 41500947}
print(student["name"], student["age"])
b. dict.get(key)--->获取key对应的值
注意：key值不存在时不会报错，返回None
print(student.get("age"))
print(student.get("score"))
print(student)
c. 遍历字典
直接遍历字典拿到的是字典key值，节约资源，推荐使用
student = {"name": "小明", "age": 18, "study_id": 41500947}
for x in student:
print(x)
使用dict.value()方法在for循环中遍历出value值,费cpu，了解
print("=================")
for value in student.values():
print(value)
使用dict.items()方法在for循环中遍历出value值,费cpu，了解
for key, value in student.items():
print(key, value)
2. 增/改(添加键值对)
添加语法：
dict[key] = value(key不存在时)
car = {}
car["color"] = "yellow"
print(car)
car["price"] = 300000
print(car)
修改语法：
dict[key] = value(key存在时)
car["price"] = 360000
print(car)
3. 删(删除键值对)
a. del dict[key] --->删除键值对
student = {"name": "小明", "age": 18, "study_id": 41500947}
del student["name"]
print(student)
b. dict.pop(key) --->取出键值对,可以赋给其他变量，拿到的是值
age = student.pop("age")
print(student, age)
5. 字典的相关运算
1. 字典不支持 + 和 * 的运算
==, is
a = {"a": 1, "b": 2, "c": 3}
b = {"a": 1, "c": 3, "b": 2}
print(a == b, a is b, sep = '\n')
in, not in 判断key是否存在于字典
a = {"a": 1, "b": 2, "c": 3}
print("b" in a, "d" in a, sep = "\n")
2. 字典相关方法
len() 判断键值对的个数
a = {"a": 1, "b": 2, "c": 3}
print(len(a))
clear() 清空字典
a = {"a": 1, "b": 2, "c": 3}
a.clear()
print(a)
copy() 拷贝一份新的字典
a = {"a": 1, "b": 2, "c": 3}
b = a.copy()
print(b, a, sep = "\n")
dict.fromkeys(序列, 值) / {}.fromkeys(序列, 值),创建一个字典
将序列中的每个元素作为key，后面的值作为value
c = {}.fromkeys("abcd", 1)
print(c)
c = {}.fromkeys([1, 2, 3, 4], "abc")
print(c)
c = {}.fromkeys([1, 2, 3], [4, 5, 6])
print(c)
dict.get(key, k) key不存在时，取k，k默认为None
print(c.get("c"), c.get("c", "没有"), sep = "\n")
dict.value() 返回获取所有值对应的序列
dict.keys() 返回获取所有key对应的序列
dict.items() 返回所有值和key转换为元组作为序列元素的序列
注意:返回的序列都不是列表、元组，是其他类型的序列
dict.setdefault(key, k) 和get类似，添加键值对,k默认为None
如果键值对存在就不修改，不存在添加
a = {"a": 1, "b": 2, "c": 3}
a.setdefault("a", 2)
a.setdefault("d", 4)
print(a)
dict1.update(dict2) 使用dict2中键值对去更新dict1
dict2 中的键值对，dict1中存在就修改，不存在就添加
a = {"a": 1, "b": 2, "c": 3}
b = {"a": 0, "d": 4, "e": 5 }
a.update(b)
print(a)
6. 集合
1. 什么是集合(set)?
格式： set = {元素1, 元素2, ……, 元素n}
元素必须是不可变的数据，唯一的(不能重复): 数字、字符串、元组,不能是列表、字典
容器， 可以同时存储多个数据，可变的，无序的
可变 ---> 可以增删,集合不能改
无序 ---> 不能通过下标获取元素
元素唯一 --->自带去重功能
注意：不能通过空{}表示空的集合
set1 = {10, 10.5, "abc", (1, 2)}
2. 集合的增删改查
a. 查(获取元素) 集合不能单独的获取一个元素，也不能切片，只能通过for-in循环遍历无序取出
for i in set1:
print(i)
b. 增(增加元素)
set.add(元素) 在集合中添加元素
set2 = {1, 2, 4}
set2.add(3)
print(set2)
set1.update(序列) 将序列中的元素添加到集合1中,字典只添加key
set3 = {1, 2, 3}
set4 = {2, 3, 4, 5, "abc"}
set3.update(set4)
print(set3)
c. 删(删除元素)
set.remove(元素) 删除指定元素
set5 = {1, 2, 3, 4, 5}
set5.remove(1)
print(set5)
d. 改(集合不能改)
7. 集合相关的运算
集合相关的运算：是否包含， 交集， 并集， 差集， 补集
1. 包含 >= <=
set1 >= set2 判断集合1是否包含集合2
set1 <= set2 判断集合2是否包含集合1
set1 = {1, 2, 3}
set4 = {1, 2, 3}
set2 = {2, 3}
set3 = {3, 4, 5}
print(set1 > set2, set1 >= set2, set1 >= set4, set3 >= set2, sep = "\n")
2. 交集 & 求两个集合共有的部分
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6, 7}
print(set1 & set2)
3. 并集 | 求两个集合相加的部分
print(set1 | set2)
4. 差集 集合1 - 集合2 (实质是set1 - 交集)
print(set1 - set2)
5. 补集 ^ 求两个集合除了共有部分以外的部分
print(set1 ^ set2)
8. 类型转换
1. 整型
int()
能转换为整型的数据类型： 浮点型、布尔、部分字符串(去掉引号本身是整数)
print(int("34"))
print(int("+34"))
print(int("-34"))
# print(int("34.5")) 报错: Value Error
2. 浮点数
float()
整数、布尔、部分字符串(去掉引号本身就是一个数字的字符串)
print(float(100))
print(float(True))
print(float("-100"))
print(float("+100"))
print(float("100.5"))
3. 布尔值
bool()
所有的数据都可以转换为bool
当值为0, False, None, [], {}, (), range(0)等为空为0时，为False
其余值为True
4. 字符串
str()
所有数据都可以转换为字符串,转换为字符串就是直接在数据外边加引号
print([str(100)])
print([str(True)])
print(str([1, 2, 3]))
print(str({}))
print(str(lambda x, y: x*y))
5. 列表
list()
序列才能转换为列表，将序列中元素取出作为列表的元素,转换字典时只取列表的key
print(list("abcdadmlk"))
print(list((23, 23, 45, 66)))
print(list({"a": 2, "b": 3, "c": 4}))
6. 元组
tuple()
只能将序列转换为元组，转换方式类似列表
print(tuple({"a": 2, "b": 3, "c": 4}))
7. 字典
dict()
只有序列且序列中每个元素有两个值才能转换为字典
list1 = [[1, 2], (3, 4)]
tuple1 = ([1, 2], (3, 4))
print(dict(list1), dict(tuple1), sep = "\n")
8. 集合
set()
序列可以转化为集合，无序并且去重
list1 = [1, 2, 3, 1, 3, 5]
print(set(list1))