前言：数据容器模块内容较多，会拆分成几个篇幅去记录和总结，以此为开篇。
目录
数据容器
数据容器定义
数据容器：一种可以容纳多份数据的数据类型，每一份数据称为一个元素，元素可以是任意类型的数据，例如字符串、数字、布尔等。
数据容器分类
数据容器分5类：列表list、元组tuple、字符串str、集合set、字典dict
数据容器：list（列表）
列表的定义
格式：[元素1，元素2，元素n]
基本语法：
变量名称=[元素1，元素2，元素n]
定义空列表
变量名称=[]
变量名称=list()
注：列表可以存储多个数据，且可以为不同类型，支持嵌套。
示例：
# 定义一个列表list
my_list = ["1", "two", "True"]
print(f"输出列表：{
my_list}")
print(f"输出列表类型：{
type(my_list)}")
# 定义一个嵌套列表
my_list = [["1", "two", "True"], [1, 2, 4, 5, 5]]
print(f"输出嵌套列表：{
my_list}")
print(f"输出嵌套列表类型：{
type(my_list)}")
运行结果：
输出列表：[‘1’, ‘two’, ‘True’]
输出列表类型：<class ‘list’>
输出嵌套列表：[[‘1’, ‘two’, ‘True’], [1, 2, 4, 5, 5]]
输出嵌套列表类型：<class ‘list’>
列表的下标索引
①利用下标索引取特定位置的数据。
②正向索引下标从左到右，从0开始，依次递增。
语法：列表[下标索引]，可以取出对应数据。
反向索引从右向左，最右为-1，向左依次递减。
注意：超出序号将会运行报错。
③嵌套列表的数据需要写对应层次的索引：列表[1][0],第二个列表的第一个数据。
示例：
# 通过下标索引取出对应位置的数据
my_list = ["1", "two", "True"]
# 使用正向
print(my_list[1]) # 应该是two
print(my_list[0]) # 应该是1
# 使用倒序
print(my_list[-1]) # 应该是True
print(type(my_list[-2]))
# 嵌套列表取法
my_list = [["1", "two", "True"], [1, 2, 4, 5, 5]]
print(my_list[1][0]) # 应该是第二个列表的第一个元素1
运行结果：
two
1
True
<class ‘str’>
1
列表的常用操作（方法）和特点
列表的方法定义
①使用下标索引获取值
②插入元素
③删除元素
④清空列表
⑤修改元素
⑥统计元素个数
等等
列表的查询功能（方法）
如果将函数定义为class（类）的成员，那么函数会称之为方法。
函数：
def add(x,y):
return x+y
方法：
class Student:
def add(self,x,y):
return x+y
函数的使用：num=add(1,2)
方法的使用：student=Student()#先获取类
num=student.add(1,2)#再指明方法
查找某元素的下标
功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index(元素)
index就是列表对象（变量）内置的方法（函数）。
示例：
mylist = ["me", "you", "they"]
# 1、查找某元素在列表内的下标索引
index = mylist.index("you")
print(f"you在列表中的下标索引值是：{
index}")
运行结果：
you在列表中的下标索引值是：1
注意：若是元素不在列表中则会出现报错。
示例：
# 查找元素不在列表内会报错
index = mylist.index("she")
print(f"she在列表中的下标索引值是：{
index}")
运行结果：
index = mylist.index(“she”)
ValueError: ‘she’ is not in list
修改特定位置（索引）的元素值：
语法：列表[下标]=值
使用以上语法，直接对指定下标（正向、反向下标均可）的值进行重新赋值（修改）。
示例：
# 修改特定下标索引的值
# 正向索引修改
mylist[0] = "我"
print(f"列表被修改元素值后，结果：{
mylist}")
# 反向索引修改
mylist[-1] = "他们"
print(f"列表被修改元素值后，结果：{
mylist}")
运行结果：
列表被修改元素值后，结果：[‘我’, ‘you’, ‘they’]
列表被修改元素值后，结果：[‘我’, ‘you’, ‘他们’]
列表的修改功能（方法）
①插入元素
语法：列表.insert（下标，元素），在指定的下标位置，插入指定的元素
②追加单个元素
语法：列表.append（元素），将指定元素，追加到列表的尾部
③追加多个元素
语法：列表.extend(其他数据容器)，将其他数据容器的内容取出，依次追加到列表的尾部
示例：
# 在指定下标位置插入新元素
mylist.insert(1, "she")
print(mylist)
# 追加元素到列表尾部
mylist.append("he")
print(mylist)
# 追加多个元素
mylist.extend([1, 2, 3])
print(mylist)
# 写法2
mylist2 = [4, 5, 6]
mylist.extend(mylist2)
print(mylist)
运行结果：
[‘我’, ‘she’, ‘you’, ‘他们’, ‘he’]
[‘我’, ‘she’, ‘you’, ‘他们’, ‘he’, 1, 2, 3]
[‘我’, ‘she’, ‘you’, ‘他们’, ‘he’, 1, 2, 3, 4, 5, 6]
删除元素
语法1：del列表[下标]
语法2：列表.pop（下标）
示例：
# 删除元素1
mylist2 = [4, 5, 6]
del mylist2[2]
print(mylist2)
# pop方法取出元素后的列表
mylist2 = [4, 5, 6]
# mylist2.pop(1)
# 可以用变量接收：element=mylist.pop(2)
element = mylist2.pop(1)
print(F"{
mylist2},取出的元素是{
element}")
运行结果：
[4, 5]
[4, 6],取出的元素是5
删除某元素在列表中的第一个匹配项（即指定内容删除）。
语法：列表.remove（元素）
示例：
# 指定元素内容删除元素
mylist = ["a", "b", "c"]
mylist.remove("b")
print(mylist)
运行结果：
[‘a’, ‘c’]
清空列表内容
语法：列表.clear()
示例：
# 清空列表内容
mylist.clear()
print(mylist)
运行结果：
[]
统计某元素在列表中的数量
语法：列表.count(元素)
示例：
# 统计某元素个数
mylist = [2, 1, 2, 2, 2, 2, 3, 3, 1, 4, 5]
count = mylist.count(2)
print(f"2的个数：{
count}")
运行结果：
2的个数：5
统计列表的总元素数量
语法：len（列表）
示例：
# 统计列表有多少元素
mylist = [2, 1, 2, 2, 2, 2, 3, 3, 1, 4, 5]
count = len(mylist)
print(f"元素个数：{
count}")
运行结果：
元素个数：11
列表的方法 - 总览
| 编号 | 使用方式 | 作用 |
|---|---|---|
| 1 | 列表.append(元素) | 向列表中追加一个元素 |
| 2 | 列表.extend(容器) | 将数据容器的内容依次取出，追加到列表尾部 |
| 3 | 列表.insert(下标, 元素) | 在指定下标处，插入指定的元素 |
| 4 | del 列表[下标] | 删除列表指定下标元素 |
| 5 | 列表.pop(下标) | 删除列表指定下标元素 |
| 6 | 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
| 7 | 列表.clear() | 清空列表 |
| 8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 9 | 列表.index(元素) | 查找指定元素在列表的下标，找不到报错ValueError |
| 10 | len(列表) | 统计容器内有多少元素 |
列表的特点
1、可以容纳多个元素（上限为2**63-1，9223372036854775807个）
2、可以容纳不同类型的元素（混装）
3、数据是有序存储的（有下标序号）
4、允许重复数据存在
5、可以修改（增加或删除元素等）
list列表的遍历
将容器内的元素依次取出进行处理的行为称之为遍历、迭代。
列表的遍历-while循环
可以使用while循环遍历列表的元素，使用列表[下标]的方式取出。
循环条件如何控制：
定义一个变量表示下标，从0开始
循环条件为下标值<列表的元素数量
语法：
index=0
while index<len（列表）:
元素=列表[index]
对元素进行处理
index+=1
示例：
def list_while_func():
"""
使用while循环遍历列表的演示函数
:return:None
"""
my_list = ["二狗", "学习", "python", "我"]
# 循环控制变量通过下标索引来控制，默认0
# 每一次循环将下标索引变量+1
# 循环条件：下标索引变量<列表的元素数量
# 定义一个变量来标记列表的下标
index = 0 # 初始值为0
while index < len(my_list):
# 通过index变量取出对应下标的元素
element = my_list[index]
print(f"列表的元素：{
element}")
# 至关重要，将循环变量（index)每一次循环都+1
index += 1
# 调用函数
list_while_func()
运行结果：
列表的元素：二狗
列表的元素：学习
列表的元素：python
列表的元素：我
列表的遍历-for循环
for循环更加适合对列表等数据容器进行遍历。
语法：
for 临时变量 in 数据容器：
对临时变量进行处理
表示从容器内，依次取出元素并赋值到临时变量上。在每一次的循环中，我们可以对临时变量（元素）进行处理。
示例：
def list_for_func():
"""
使用for循环遍历列表的演示函数
:return: None
"""
my_list = [1, 2, 3, 4, 5]
# for 临时变量 in 数据容器：
for element in my_list:
print(f"列表的元素有：{
element}")
#调用函数
list_for_func()
运行结果：
列表的元素有：1
列表的元素有：2
列表的元素有：3
列表的元素有：4
列表的元素有：5
while和for循环的对比
①在循环控制上：
while循环可以自定义循环条件，并自行控制。
for循环不可以自定义循环条件，只可以一个个从容器内取出数据。
②在无限循环上：
while循环可以通过条件控制做到无限循环。
for循环理论上不可以，因为被遍历的容器容量不是无限的。
③在使用场景上：
while循环适用于任何想要循环的场景。
for循环适用于遍历数据容器的场景或是简单的固定数次的循环场景。
总而言之：
for循环更简单，while更灵活。
for用于从容器内依次取出元素并处理，while用于以任何需要循环的场景。