数据容器介绍
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同，如：
· 是否支持重复元素
· 是否可以修改
· 是否有序，等
分为五类，分别是：
列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
数据容器：list（列表）
列表（list）的介绍：
列表（list）类型，是数据容器的一类，可以一次存储多个数据。
基本语法：
字面量
[元素1,元素2,元素3,...]
定义变量
变量名称=[元素1,元素2,元素3,...]
定义空列表
变量名称=[ ]
变量名称=list( )
列表内的每一个数据，称之为元素
· 以 [ ] 作为标识
· 列表内的每一个元素，逗号隔开
python
# 列表（list）
name = ['python','c','c++','java']
print(name)
print(type(name))
# 列表嵌套
name_list = [[1,2,"haha"],[4,5,True]]
print(name_list)
print(type(name_list))注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套
列表（list）的下标索引：
我们可以通过下标索引的方式找到列表中特定位置的元素。
比如：
python
# 列表索引
my_list = ["tom","jack","lihua"]
print(my_list[0]) # 结果为tom
print(my_list[1]) # 结果为jack
print(my_list[2]) #结果为lihua或者可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3....）
比如：
python
my_list = ["tom","jack","lihua"]
print(my_list[-3]) # 结果为tom
print(my_list[-2]) # 结果为jack
print(my_list[-1]) #结果为lihua嵌套索引的下标索引：
比如：
python
# 嵌套列表的下标索引
name_list = [[1,2,"haha"],[4,5,True]]
print(name_list[1][2]) # 结果为True
print(name_list[0][2]) # 结果为haha需要注意的是不要超出下标索引的范围，超出范围无法取出元素，会造成越界。
列表的常用操作：
列表除了可以定义和使用下标索引获取值，此外还有一系列功能：
1、插入元素
2、删除元素
3、清空元素
4、修改元素
5、统计元素个数
等等，这些功能统称为列表的方法
1、列表的查询功能
查询指定元素在列表中的下标，如果找不到，报错ValueError
语法：
列表.index(元素)
index就是列表对象（变量）内置的方法（函数）
python
# 查询下标索引
name = ['python','c','c++','java']
index = name.index("python")
print(f"python在列表中的下标索引为{index}")
# 如果被查找元素不存在，则会报错
index = name.index("javascript")
print(f"python在列表中的下标索引为{index}")2、列表的修改功能
修改特定位置（索引）的元素值：
语法：列表[下标]=值
可以使用如上语法，直接对指定下标（正向、或反向均可）的值进行重新赋值
python
# 修改特定位置元素值
my_list = [1,2,3,4]
my_list[0] = 8
print(my_list)
my_list[-1] = 6
print(my_list)插入元素：
语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素
python
# 插入元素
my_list = [1,2,3,4]
my_list.insert(2,'haha')
print(my_list)追加元素：
语法：列表.append(元素)，将指定元素，追加到列表的尾部
python
# 追加元素
my_list = [1,2,3,4]
my_list.append(4) # 结果：[1,2,3,4,4]
print(my_list)
my_list.append([5,5,6])
print(my_list) #结果：[1, 2, 3, 4, 4, [5, 5, 6]]追加方式2：
语法2：列表.extend(其他数据容器)，将其他数据容器内容取出，以此追加到列表尾部
python
# 追加一批元素
my_list = [1,2,3,4]
my_list.extend([4,5,6])
print(my_list) #结果为：[1, 2, 3, 4, 4, 5, 6]删除元素：
语法1：del列表[下标]
语法2：列表.pop(下标)
python
# 删除元素
my_list = [1,2,3,4]
# 方式1：
del my_list[0]
print(my_list) #结果为：[2, 3, 4]
# 方式2：
my_list.pop(0)
print(my_list) #结果为：[3, 4]删除某元素在列表中的第一个匹配项：
语法：列表.remove(元素)
python
my_list = [1,2,3,2]
my_list.remove(2)
print(my_list) # 结果为：[1, 3, 2]清空列表内容：
语法： 列表.clear()
python
# 清空列表内容
my_list = [1,2,3,2]
my_list.clear()
print(my_list)统计某元素在列表中的数量：
语法：列表.count(元素)
python
# 统计2在列表中的次数
my_list = [1,2,3,2]
num = my_list.count(2)
print(num)统计列表内，有多少元素：
语法：len(列表)
python
# 统计列表内，有多少元素
my_list = [1,2,3,2]
count = len(my_list)
print(count)列表的特点：
1、可以容纳多个元素（上限为2**63-1个）
2、可以容纳不同类型的元素
3、数据是有序存储的
4、允许重复数据存在
5、可以修改
list（列表）的遍历
既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。
列表的遍历-while循环
通过定义一个从0开始的下标变量，循环条件为 下标值<列表中元素数量来实现遍历。
index = 0
while index < len(列表):
元素 = 列表[index]
对元素进行处理
index +=
python
def list_while_func():
"""
使用while循环遍历列表的演示函数
:return:
"""
my_list = ["python","java","c++","javascript","go"]
index = 0;
while index < len(my_list):
element = my_list[index]
print(f"列表的元素：{element}")
index += 1
list_while_func()列表的遍历-for循环
除了while循环，python中还有另一种循环的形式：for循环。对比while，for循环更加适合对列表等数据容器进行遍历
语法：
for 临时变量 in数据容器:
对临时变量进行处理
表示从容器内，依次取出元素并赋值到临时变量上。在每一次的循环中，我们可以对临时变量进行处理。
python
def list_for_func():
"""
使用for循环遍历列表的演示函数
:return:
"""
my_list = ["python","java","c++","javascript","go"]
for element in my_list:
print(f"列表的元素：{element}")
list_for_func()while循环与for循环的对比：
1、在循环控制上：while循环可以自定循环条件，并自行控制；for循环不可以自定循环条件，只可以一个个从容器内取出数据
2、在无限循环上：while循环可以通过条件控制做到无限循环；for循环理论上不可以，因为被遍历的容器容量不是无限的
3、在使用场景上：while循环适用于任何想要循环的场景；for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
数据容器：tuple（元组）
因为列表是可以被修改的，如果想要传递的信息，不被篡改，列表是不合适的。而元组与列表最大的不同就在于：元组一旦定义完成，就不可修改。
元组定义：定义使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
定义元组字面量
(元素,元素,......,元素)
定义元组变量
变量名称=(元素,元素,......,元素)
定义空元组
变量名称=( )
变量名称=tuple( )
python
t1 = (1,"hehe",True)
t2=()
print(f"t1的类型:{type(t1)}")
print(f"t1的类型:{type(t2)}")
t3 = ("haha",) #元组中只有一个数据，这个数据后面添加逗号,否则类型变为str
# 元组嵌套
t = ((1,2,3),(4,5,6))
print(f"t的类型:{type(t)},内容是：{t}")元组（tuple）的下标索引：
python
t = ((1,2,3),(4,5,6))
print(f"t的类型:{type(t)},内容是：{t}")
# 元组索引
print(t[1][2])元组的相关操作：
|----|---------|--------------------------|
| 编号 | 方法 | 作用 |
| 1 | index() | 查找某个数据，如果数据存在返回对应下标，否则报错 |
| 2 | count() | 统计某个数据在当前元组出现的次数 |
| 3 | len() | 统计元组内的元素个数 |
python
# 根据index()，，查找第一个特定元素的匹配项
t1 = (1,2,"hehe",3,4,"hehe")
index = t1.index("hehe")
print(index) #结果为2
# 统计某个元素在元组中的个数
count = t1.count("hehe")
print(count) #结果为2
# 统计元组中元素个数
print(len(t1)) #结果为6元组（tuple）的遍历
元组的遍历-while循环：
python
# 元组的遍历-while循环
t1 = (1,2,"hehe",3,4,"hehe")
index = 0
while index < len(t1):
print(f"元组的元素有:{t1[index]}")
index += 1元组的遍历-for循环：
python
# 元组的遍历-for循环
t2 = (1,2,"hehe",3,4)
index = 0
for element in t2:
print(f"元组的元素有：{element}")注意事项：不可以修改元组内容，否则会直接报错；但是如果在元组中嵌套了一个列表，那么列表中的元素是可以修改的。
数据容器：str（字符串）
字符串是字符的容器，一个字符串可以存放任意数量的字符。
字符串的下标索引：
和其他容器如：列表、元组一样，字符串也可以通过下标进行访问。
· 从前往后，下标从0开始
· 从后向前，下标从-1开始
python
# 字符串索引
str1 = "hello"
print(str1[0]) #结果为h同元组一样，字符串是一个无法修改的数据容器。所以：
修改指定下标的字符、移除特定下标的字符、追加字符等均无法完成。如果必须要做，只能得到一个新字符串，旧的字符串无法修改。
字符串的常用操作：
1、查找特定字符串的相关索引值。
语法：字符串.index(字符串)
python
# 字符串查找特定元素的下标
str1 = "hello word"
index = str1.index("hello")
print(index) # 结果是字符串第一个元素的位置2、字符串的替换
语法：字符串.replace(字符串1，字符串2)
功能：将字符串的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新的字符串
python
# 字符串的替换
str1 = "hello word"
new_str1 = str1.replace("h","H")
print(new_str1) #结果为：Hello word3、字符串的分割
语法：字符串.split(分隔符字符串)
功能：将按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中。
注意：字符串本身不变，而是得到了一个列表对象
python
# 字符串分割
str1 = "hehe haha xixi"
list1 = str1.split(" ")
print(f"将字符串{str1}进行分割后得到{list1}，它的类型为：{type(list1)}")
# 运行结果：将字符串hehe haha xixi进行分割后得到['hehe', 'haha', 'xixi']，它的类型为：<class 'list'>4、字符串的规整操作（去前后空格）
语法：字符串.strip()
python
# 字符串规整操作，去前后空格
str1 = " hello word "
print(str1.strip())5、字符串的规整操作（去前后指定字符串）
语法：字符串.strip(字符串)
python
# 字符串的规整操作（去前后指定字符串）
str1 = "12@hello word@21"
print(str1.strip("12@"))6、统计字符串中某个元素的个数
语法：字符串.count(字符)
python
str1 = "hello word"
count = str1.count("o")
print(count) # 结果为27、统计字符串长度
语法：len(字符串)
python
# 统计字符串长度
str1 = "hello word"
count = len(str1)
print(count) #结果为10作为数据容器，字符串有如下特点：
1、只可以存储字符串
2、长度任意
3、支持下标索引
4、允许重复字符串存在
5、不可以修改
6、支持while、for循环
数据容器（序列）的切片
序列是指内容连续、有序，可以使用下标索引的一类数据容器。元组、列表、字符串均可以视为序列。
序列至此切片，即：列表、元组、字符串，均支持进行切片操作。
切片：从一个序列中，取出一个子序列
语法：序列[起始下标：结束下标：步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
· 起始下标表示从何处开始，可以留空，留空视作从头开始
· 结束下标（不含）表示何处结束，可以留空，留空是做截取到结尾
· 步长表示，依次取元素的间隔
· 步长1表示一个个取元素
· 步长2表示每次跳过一个元素
· 步长n表示每次跳过n-1个元素
· 步长为负数表示，反向取（起始下标与结束下标也要反向标记）
注意：此操作不会影响序列本身，而是会得到一个新序列（元组和字符串不可修改）
python
# 对list切片，从一到四，步长为1
my_list = [0,1,2,3,4,5,7]
result1 = my_list[1:5]
print(result1)
# 对元组进行切片，从头开始到位结束，步长为-2
my_tuple = [0,1,2,3,4,5,6]
result2 = my_tuple[::-2]
print(result2)
python
# 案例：万过薪月，员序程马黑来，nohtyp学
# 1、倒序字符串，切片取出或切片取出，然后倒序
str1 = "万过薪月，员序程马黑来，nohtyp学"
str2= str1[::-1][9:14]
print(str2)
str3 = "万过薪月，员序程马黑来，nohtyp学"
str4 = str1[5:10][::-1]
print(str4)
# 2、split分割"，"replace替换来为空，倒序字符串
str5 = "万过薪月，员序程马黑来，nohtyp学"
str6 = str5.split("，")[1].replace("来","")[::-1]
print(str6)数据容器：set（集合）
集合是不支持重复元素的，会对重复元素进行去重操作、并且内容无序。
基本语法：
定义集合字面量
{元素,元素,......,元素}
定义集合变量
变量名称={元素,元素,......,元素}
定义空集合
变量名称=set( )
python
set1 = {"haha","hehe","xixi","haha"}
print(f"set1的内容为：{set1},类型：{type(set1)}") #set1的内容为：{'haha', 'hehe', 'xixi'},类型：<class 'set'>
set2 = set() # 空集合集合的常用操作：
首先，因为集合是无序的，所以不支持下标索引访问。但是集合和列表一样，是允许修改的，因此我们来看集合的修改方法。
1、添加新元素
语法：集合.add(元素)。将指定元素添加到集合内
结果：集合本身被修改，添加了新元素
python
# 给集合添加元素
my_set = {"haha","hehe","xixi"}
my_set.add("python")
print(my_set)# 结果为：{'hehe', 'haha', 'python', 'xixi'}是无序的2、移除元素
语法：集合.remove(元素)。将指定元素从集合中删除
结果：集合本身被修改，删除了指定元素
python
my_set = {"haha","hehe","xixi"}
my_set.remove("haha")
print(my_set) #结果为：{'hehe', 'xixi'}3、随机取出一个元素
语法：集合.pop( )。将元素从集合中随机删除
结果：会得到一个元素的结果。同时集合本身被修改
python
# 随机取出一个元素
my_set = {"haha","hehe","xixi"}
pop_set = my_set.pop()
print(f"随机取出的元素为{pop_set},集合中的元素为{my_set}") #随机取出的元素为haha,集合中的元素为{'hehe', 'xixi'}4、清空集合
语法：集合.clear( )
python
#清空集合
my_set = {"haha","hehe","xixi"}
my_set.clear()
print(my_set)5、取出两个集合的差集
语法：集合1.difference(集合2)，功能：取出集合1与集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1与集合2不变
python
# 两个集合的差集
my_set1 = {1,3,5}
my_set2 = {1,4,6}
new_set = my_set1.difference(my_set2)
print(new_set) # 结果：{3, 5}
print(my_set1) # 结果：{1, 3, 5}
print(my_set2) # 结果：{1, 4, 6}6、消除两个集合的差集
语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
结果：集合1被修改，集合2不变
python
# 消除两个集合的差集
my_set1 = {1,3,5}
my_set2 = {1,4,6}
my_set1.difference_update(my_set2)
print(my_set1) # 结果：{3, 5}
print(my_set2) # 结果：{1, 4, 6}7、两个集合合并为一个
语法：集合1.union(集合2)
功能：将集合1和集合2组成新集合
结果：得到新集合，集合1和集合2不变
python
# 两个集合合并为一个
my_set1 = {1,3,5}
my_set2 = {1,4,6}
new_set = my_set1.union(my_set2)
print(new_set) #结果为：{1, 3, 4, 5, 6}
print(my_set1) #结果为：{1, 3, 5}
print(my_set2) #结果为：{1, 4, 6}8、统计集合数量
语法：len(集合)
python
my_set = {1,2,3,4,5,6}
num = len(my_set)
print(num)集合（set）的遍历
因为集合不支持下标索引，所以不能用while循环，但可以使用for循环
python
# for循环
my_set = {1,2,3,4,5,6}
for element in my_set:
print(f"集合中的元素有：{element}")数据容器：dict（字典、映射）
通过字典，我们可以通过用key取value的操作。
字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：
定义字典字面量
{key:value,key:value,......,key:value}
定义字典变量
变量名={key:value,key:value,......,key:value}
定义空字典
变量名={}
变量名=dict( )
字典同样不支持key的重复，如果重复，第一个key会被覆盖掉。
字典同集合一样，不可以使用下标索引。但是字典可以通过key值来取得对应的value
语法：字典[key]可以取到对应的value
python
my_dict = {"张三":99,"李四":88,"王二":77}
print(f"字典的内容为：{my_dict},类型：{type(my_dict)}")
score = my_dict["张三"]
print(score) # 99字典的嵌套
字典的key和value可以是任意类型（key不可以为字典）
那么，就表明，字典是可以嵌套的
python
score_dict = {
"张三":{
"语文":77,
"数学":66,
"英语":33
},"李四":{
"语文":88,
"数学":86,
"英语":55
},"王二":{
"语文":99,
"数学":96,
"英语":66
}
}
print(f"学生的考试信息:{score_dict}")字典（dict）的常用操作：
1、新增元素
语法：字典[key]=value,字典被修改，新增了元素
python
my_dict = {"张三":99,"李四":88,"王二":77}
my_dict["麻子"] = 67
print(my_dict) #{'张三': 99, '李四': 88, '王二': 77, '麻子': 67语法：字典[key]=value,字典被修改，元素被更新
注意：字典key不可以重复，所以对已经存在的key执行上述操作，就是更新value值
python
# 更新元素
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
my_dict["麻子"] = 68
print(my_dict) #{'张三': 99, '李四': 88, '王二': 77, '麻子': 68}3、删除元素
语法：字典.pop(key)，结果：获得指定key的value，同时字典被修改，指定key的数据被删除
python
# 删除元素
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
score = my_dict.pop("麻子")
print(f"字典被移除一个元素，结果{my_dict},麻子的分数："{score}")4、清空元素
语法：字典.clear( )
5、获取全部的key
语法：字典.keys( )
结果：得到字典中的全部key
python
# 取出全部key
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
keys = my_dict.keys()
print(keys) #dict_keys(['张三', '李四', '王二', '麻子'])6、字典内元素数量
语法：len(字典变量名)
python
# 字典中元素数量
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
num = len(my_dict)
print(num)字典（dict）的遍历：
python
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
num = len(my_dict)
print(num)
# 取出全部key
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
keys = my_dict.keys()
for key in keys:
print(f"字典的key是:{key}")
print(f"字典的value是:{my_dict[key]}")
python
emp_dict = {
"马云":{
"部门":"科技部",
"薪资":3000,
"级别":1
},"李彦宏":{
"部门":"市场部",
"薪资":5000,
"级别":2
},"刘强东":{
"部门":"市场部",
"薪资":7000,
"级别":4
},"张一鸣":{
"部门":"科技部",
"薪资":4000,
"级别":1
}
}
for name in emp_dict:
if emp_dict[name]["级别"] == 1:
info_emp_dict = emp_dict[name]
info_emp_dict["级别"] = 2
info_emp_dict["薪资"] += 1000
emp_dict[name]=info_emp_dict
print(f"升职加薪后的结果为：{emp_dict}")数据容器的通用操作
首先在遍历上，5类数据容器都支持for循环遍历；列表、元组、字符串支持while循环，集合、字典不支持while循环。
除了下标索引这个共性以外，还可以同哟个类型转换。比如list（容器）-将给定容器转换为列表、set（容器）-将给定容器转换为集合等等。
通用排序功能：
sorted(容器，[reverse=True])
将给定容器进行排序
python
my_list = [1,4,6,8,2,3]
print(f"列表的排序结果:{sorted(my_list,reverse=True)}") # 反向排序
print(f"列表的排序结果:{sorted(my_list)}")