文章介绍了Python中的数据容器概念，重点讲解了列表和元组的定义、操作以及遍历方法。列表作为可变数据类型，支持多种操作，如插入、删除、追加元素，以及元素的下标访问。元组则为不可变数据类型，定义和遍历方式与列表相似，但不允许修改其内容。文章还提供了多个示例和练习案例来帮助理解这些概念。
这节内容比较多，所以分成上下两part啦
目录
一、数据容器入门
1)为什么要学习数据容器？
思考一个问题:如果我想要在程序中，记录5名学生的信息，如姓名，如何做呢?
复杂的方法：定义五个变量
因此引入数据容器，一个变量就可以记录五分份数据
name_list = ['lxl', 'asd', 'fgh', 'sdf', 'fxc'] print(name_list)
2）什么是数据容器？
Python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同，如:
是否支持重复元素
是否可以修改
是否有序，等
分为了五类，分别是：
列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
二、数据容器:list(列表)
1）列表的定义
为什么需要列表？
思考：有一个人的姓名(TOM) 怎么在程序中存储?
答：字符串变量
思考:如果一个班级100位学生，每个人的姓名都要存储，应该如何书写程序?声明100个变量吗？
答:No，我们使用列表就可以了， 列表一次可以存储多个数据
列表 (list)类型，是数据容器的一类，我们来详细学习它
基本语法：
# 字面量
[元素1， 元素2， 元素3， 元素4，...]
# 定义变量
变量名称 = [元素1， 元素2， 元素3， 元素4，...]
# 定义空列表
变量名称 = []
变量名称 = list()列表内的每一个数据，称之为元素
以[ ]作为标识
列表内每一个元素之间用，逗号隔开
name_list = ['study', 'lxl', 'python']
print(name_list)
print(type(name_list))
my_list = ['itheima', 666, True]
print(my_list)
print(type(my_list))
无论列表里存储的元素类型可以是不同的数据类型，这一点不受限制
还可以在列表中存储一个列表，称为嵌套
2）列表的下标索引
如何从列表中取出特定位置的数据呢?
我们可以使用:下标索引
列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增
我们只需要按照下标索引，即可取得对应位置的元素。
# 语法， 列表[下标索引] name_list = [ Tom', 'Lily', 'Rose'] print(name_list[o]) # 结果，Tom print(name_list[1])# 结果，Lily print(name_list[2]) #结果，Rose
下标索引-反向
从后向前，下标索引为: -1、-2、-3，依次递减。
# 语法: 列表[标号] name_list = ['Tom','Lily,'Rose'] print(name_list[-1]) # 结果:Rose print(name_list[-2]) # 结果:Lily print(name_list[-3]) # 结果，Tom
嵌套列表的下标（索引）
取出嵌套列表的元素
my_list2 = [[1, 2, 3], [4, 5, 6]] print(my_list2[1][1])
3）列表的常用操作
列表除了可以:
定义
使用下标索引获取值
以外，列表也提供了一系列功能:
插入元素
删除元素
清空列表
修改元素
统计元素个数等等功能，这些功能我们都称之为: 列表的方法
列表查询功能（方法）
回忆:函数是一个封装的代码单元，可以提供特定功能。
在Python中，如果将函数定义为class (类)的成员，那么函数会称之为:方法
class Student: def add(self，x，y): return x + y方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同
函数的使用:num = add(1，2)
方法的使用:student = Student()
num = studentadd(1,2）
查找某元素的下标
功能:查找指定元素在列表的下标如果找不到，报错ValueError
语法: 列表.index(元素)
index就是列表对象(变量)内置的方法(函数）
# 演示数据容器之：list列表的基本操作 mylist = ["itcast", "itheima", "python"] # 1.1查找某元素在列表内的下标索引 index = mylist.index("itheima") print(f"itheima在列表中的下标索引是:{index}") # 1.2如果被查找的元素不存在，会报错 index = mylist.index("hello") print(f"hello在列表中的下标索引是:{index}")1.2是错误示范哦
修改特定位置(索引)的元素值:
语法: 列表[下标]= 值
可以使用如上语法，直接对指定下标(正向、反向下标均可)的值进行:重新赋值(修改)
# 正向下标 my_list = [1，2，3] my_list[0] =5 print(my_list) # 结果: [5，2，3] # 反向下标 my_list = [1，2，3] my_list[-3] = 5 print(my_list) # 结果: [5，2，3]示例：
# 2.修改特定下标索引的值 mylist[0] = "happy" print(f"列表被修改元素值后，结果是：{mylist}")
插入元素:
语法: 列表.insert(下标,元素)，在指定的下标位置，插入指定的元素
my_list = [1，2，3] my_list.insert(1，"itheima") print(my_list) # 结果: [1，"theima"，3，4]示例：
# 3.在指定下表位置插入新元素 mylist.insert(1, "best") print(f"列表插入元素后，结果是：{mylist}")
追加元素：
语法: 列表appena(元素)，将指定元素，追加到列表的尾部
my_list = [1，2，3] my_1ist.append(4) print(my_ist)# 结果: [1，2，3，4] my_list = [1，2，3] my_list.append([4，5，6]) print(my_list)示例：
# 4.在列表的尾部追加'''单个'''新元素 mylist.append("黑马程序员") print(f"列表在追加了元素后，结果是：{mylist}")
追加元素方式2：
语法: 列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部
my_list = [1，2，3] my_list.extend([4，5，6]) print(my_list)# 结果: [1，2，3，4，5，6]示例：
# 5.在列表的尾部追加'''一批'''新元素 mylist2 = [1, 2, 3] mylist.extend(mylist2) print(f"列表追加了一个新的列表后，结果是:{mylist}")
删除元素：
# 6.1 方式1：del 列表[下标] del mylist[2] print(f"列表删除python后，结果是：{mylist}") # 6.2 方式2：列表.pop(下标) mylist = ["itcast", "itheima", "python"] element = mylist.pop(2) print(f"列表删除python后，结果是：{mylist}") print(f"去除掉的元素是：{element}")第二种方法还可以通过变量接受 第一种方法只能实现删除
删除某元素在列表中的第一个匹配项
语法: 列表.remove(元素)
my_list = [1，2，3，2，3] my_list.remove(2) print(my_list) # 结果: [1，3，2，3]示例：
# 7.删除某元素在列表中的第一个匹配项 mylist = ["itcast", "itheima","itcast", "itheima", "python"] mylist.remove("itheima") print(f"通过remove方法一处元素后，列表的信息是：{mylist}")
清空列表内容：
语法:列表.clear()
my_list = [1，2，3] my_list.clear() print(my_list) # 结果， []示例：
# 清空列表 mylist = ["itcast", "itheima","itcast", "itheima", "python"] mylist.clear() print(f"通过remove方法后，列表的信息是：{mylist}")
统计某元素在列表内的数量
语法: 列表.count(元素)
my_list = [1，1，1，2，3] print(my_list.count(1)) # 结果: 3示例：
# 统计某元素在列表内的数量 mylist = ["itcast", "itheima","itcast", "itheima", "python"] count = mylist.count("itcast") print(f"mylist中”itcast的个数有:{count}个")
统计列表内，有多少元素
语法: len(列表)可以得到一个int数字，表示列表内的元素数量
my_list = [1，2，3，4，5] print(len(my_list)) # 结果5示例：
# 统计列表内，有多少元素 mylist = ["itcast", "itheima","itcast", "itheima", "python"] count = len(mylist) print(f"列表的元素数量总共：{count}")
4）列表的方法 - 总览
| 使用方法 | 作用 |
| 列表append(元素) | 向列表中追加一个元素 |
| 列表.extend(容器) | 将数据容器的内容依次取出，追加到列表尾部 |
| 列表.insert(下标，元素) | 在指定下标处，插入指定的元素 |
| del列表[下标] | 删除列表指定下标元素 |
| 列表pop(下标) | 删除列表指定下标元素 |
| 列表remove(元素) | 从前向后，删除此元素第一个匹配项 |
| 列表.clear（） | 清空列表 |
| 列表.count(元案) | 统计此元豪在列表中出现的次数 |
| 列表index(元素) | 查找指定元素在列表的下标找不到报错ValueError |
| len(列表) | 统计容器内有多少元素 |
5）练习案例：
# 练习案例 # 定义这个列表，并用变量接收 student_age = [21, 25, 21, 23, 22, 20] print(f"当前列表信息为：{student_age}") # 追加31 student_age.append(31) print(f"追加31后，目前的列表信息为：{student_age}") # 追加一个新列表 student_age2 = [29, 33, 30] student_age.extend(student_age2) print(f"追加一个新列表后，目前的列表信息为：{student_age}") # 取出第一个元素 first = student_age[0] print(f"第一个元素为：{first}") # 取出最后一个元素 last = student_age[-1] print(f"最后一个元素为：{last}") # 查找元素31的下标位置 index = student_age.index(31) print(f"元素31的下标为：{index}")运行效果：
三、list(列表)的遍历
1）学习目标：
1.掌握使用while循环，遍历列表的元素
2.掌握使用for循环，遍历列表的元素
2）列表的遍历-while循环
既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为，称之为:遍历、选代。
1.如何遍历列表的元素呢?
可以使用前面学过的while循环
2.如何在循环中取出列表的元素呢?使用列表[下标]的方式取出
3.循环条件如何控制?定义一个变量表示下标，从0开始
循环条件为 下标值 <列表的元素数量
index = 0
while index < len(列表):
元素 = 列表[index]
对元素进行处理
index += 1示例：
def list_while_func(): """ 使用while循环便利列表的演示函数 :return: """ my_list = ["happy", "python", "learn"] # 循环控制变量通过下标索引来控制，默认0 # 每一次循环将下标索引变量+1 # 循环条件：下标索引变量 < 列表的元素数量 # 定义一个变量来标记列表的下标 index = 0 # 初始值为0 while index < len(my_list): element = my_list[index] print(f"列表的元素是：{element}") index += 1 # 调用函数 list_while_func()注：记得调用函数
3）列表的遍历-for循环
示例：
def list_for_func(): my_list = [1, 2, 3, 4, 5] for element in my_list: print(f"列表的元素由：{element}") list_for_func()
4）while循环和for循环的对比
while循环和for循环，都是循环语句，但细节不同:
在循环控制上:
1.while循环可以自定循环条件,并自行控制
2.for循环不可以自定循环条件,只可以一个个从容器内取出数据在无限循环上:
1.while循环可以通过条件控制做到无限循环
2.for循环理论上不可以，因为被遍历的容器容量不是无限的在使用场景上:
while循环适用于任何想要循环的场景
for循环适用于,遍历数据容器的场景或简单的固定次数循环场景
5）练习案例：
def list_for_func(): for element in my_list: if element % 2 == 0: # global new_list new_list.append(element) # print(f"列表:{new_list}") list_for_func() print(f"通过for循环，从列表:{my_list}中取出偶数，组成新列表:{new_list}")使用for循环代码实现
四、数据容器: tuple(元组)
1）为什么需要元组？
思考:列表是可以修改的。
如果想要传递的信息，不被篡改，列表就不合适了。
元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于:
元组一旦定义完成,就不可修改
所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了
2）定义元组
元组定义:定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
# 定义元组字面量 (元素，元素，......，元素) # 定义元组变量 变量名称 = (元素，元素，.......，元素） # 定义空元组 变量名称 = () #方式1 变量名称 = tuple() #方式2
示例：
# 定义元组 t1 = (1, "Hello", True) t2 = () t3 = tuple() print(f"t1的类型是：{type(t1)},内容是：{t1}") print(f"t2的类型是：{type(t2)},内容是：{t2}") print(f"t3的类型是：{type(t3)},内容是：{t3}")
需要注意的是：
#定义3个元素的元组 t1 = (1，“Hello'，True) #定义1个元素的元组 t2 = ('Hello'，) # 注意，必须带有逗号，否则不是元组类型 # 注意:元组只有一个数据，这个数据后面要添加逗号
定义单个元素的元组
# 定义单个元素的元组 t1 = ("hello", ) print(f"t1的类型是:{type(t1)},内容是：{t1}")运行效果：
元组的嵌套
# 元组的嵌套 t5 = ((1, 2, 3), (4, 5, 6)) print(f"t5的类型是:{type(t5)},内容是：{t5}")运行效果：
取出嵌套元组中的元素：
t5 = ((1, 2, 3), (4, 5, 6)) print(f"t5的类型是:{type(t5)},内容是：{t5}") num = t5[1][2] print(f"从嵌套元组取出的数据是：{num}")
3）元组的相关操作
| 方法 | 作用 |
| index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| count() | 统计某个数据在当前元组出现的次数 |
| len(元组) | 统计元组内的元素个数 |
4）元组的遍历
# 元组的遍历：while
t8 = ("happy", "python", "learn")
index = 0
while index < len(t8):
print(f"元组的元素有：{t8[index]}")
index += 1
# 元组的遍历：for
for element in t8:
print(f"for循环中元组的元素有：{element}")元组的遍历和列表很类似，都比较简单
5）元组的特点
经过上述对元组的学习，可以总结出列表有如下特点:
可以容纳多个数据
可以容纳不同类型的数据（混装）数据是有序存储的(下标索引）
允许重复数据存在
不可以修改(增加或删除元素等)
支持for循环
多数特性和list一致，不同点在于不可修改的特性
6）练习案例
# 练习案例
recode = ('周杰伦', 11, ['football', 'music'])
# 查询年龄所在位置
index = recode.index(11)
print(f"年龄所在的下标位置在：{index}")
# 查询学生的姓名
name = recode[0]
print(f"学生的姓名为：{name}")
# 删除football.
del recode[2][0]
print(f"删除football之后的元组为：{recode}")
# 增加coding
recode[2].append("coding")
print(f"增加爱好coding后元组为：{recode}")ok，以上就是今天学习的部分数据容器的知识啦，目前只更新到列表和元组，明天更新剩下的部分
一起愉快的学习python吧lol
354
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
