【python】Python基础语法详细教程以及案例教学之数据容器（上）（列表、元组）_python 数据容器例题

这节内容比较多，所以分成上下两part啦

目录

一、数据容器入门

1)为什么要学习数据容器？

2）什么是数据容器？

二、数据容器:list(列表)

1）列表的定义

2）列表的下标索引

3）列表的常用操作

列表查询功能（方法）

查找某元素的下标

修改特定位置(索引)的元素值:

插入元素:

追加元素：

追加元素方式2：

删除元素：

删除某元素在列表中的第一个匹配项

清空列表内容：

统计某元素在列表内的数量

统计列表内，有多少元素

语法: len(列表)

4）列表的方法 - 总览

5）练习案例：

三、list(列表)的遍历

1）学习目标：

2）列表的遍历-while循环

3）列表的遍历-for循环

4）while循环和for循环的对比

5）练习案例：

四、数据容器: tuple(元组)

1）为什么需要元组？

2）定义元组

定义单个元素的元组

元组的嵌套

3）元组的相关操作

4）元组的遍历

5）元组的特点

6）练习案例

---

一、数据容器入门

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）列表的方法 - 总览

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）元组的相关操作

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