欢迎大家订阅【Python从入门到精通】专栏,一起探索Python的无限可能!
前言
在Python中,数据容器是处理和存储信息的基本工具。本章将从数据容器的基础知识开始,逐步深入讲解列表的定义、下标索引、常用操作以及遍历方法。
本篇文章参考:黑马程序员
一、数据容器入门
Python中的数据容器是一种可以容纳多份数据的数据类型。容纳的每一份数据称之为一个元素,每一个元素可以是任意类型的数据,如字符串、数字、布尔等。
数据容器根据不同的特点可分为5类,分别是列表(list)、元组(tuple)、字符串(str)、集合(set)以及字典(dict)。
二、列表的定义
①基本语法:
列表内的每一个数据称之为元素,以 [] 作为标识,每一个元素之间用逗号隔开。
- 定义字面量:
[元素1,元素2,元素3,元素4,…] - 定义变量:
变量名称 = [元素1,元素2,元素3,元素4,…] - 定义空列表:
方式一:变量名称 = []
方式二:变量名称 = list()
②特点:
- 可一次存储多个数据(上限为2**63-1个,即9223372036854775807个)
- 数据是有序存储的(有下标序号)
- 可修改(增加或删除元素等)
- 可存储不同类型的数据
- 允许重复数据存在
- 支持嵌套
# 定义一个列表list
list1=["你好",666,True]
print(list1)
print(type(list1))
输出结果:
[‘你好’, 666, True]
<class ‘list’>
# 定义一个嵌套的列表
list2=[[1,2,3],[7,8,9]]
print(list2)
print(type(list2))
输出结果:
[[1, 2, 3], [7, 8, 9]]
<class ‘list’>
三、列表的下标索引
思考:我们如何从列表中取出特定位置的数据呢?
答:可以使用下标索引
①基本语法:
列表[标号]
②索引范围:
如下图,列表中的每一个元素,都有其位置下标索引。我们只需要按照下标索引,即可取得对应位置的元素。
正向的下标索引:从前向后的方向,从0开始,依次递增(0、1、2……)。
注意:下标索引的取值不能超出取值范围,否则无法取出元素并且会报错
# 通过下标索引取出对应位置的数据
my_list=["A","B","C"]
# 正向的下标索引:从前向后:从0开始,每次+1
#通过下标索引取出数据
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范:通过下标索引取出数据,一定不能超出范围
#print(my_list[3]) 报错:IndexError: list index out of range
输出结果:
A
B
C
反向的下标索引:从后向前:从-1开始,依次递减(-1、-2、-3…)。
my_list=["A","B","C"]
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
输出结果:
C
B
A
嵌套的列表,同样支持下标索引。先取出外层列表的下标索引,再取出内层列表的下标索引。
#取出嵌套列表的元素
my_list=[[1,2,3],[7,8,9]]
print(my_list[1][1])
输出结果:
8
这段代码中,my_list是一个包含两个子列表的列表,即[[1,2,3],[7,8,9]]。my_list[1][1]首先会访问my_list列表中索引为1的元素,即第二个子列表 [7,8,9]。然后在这个第二个子列表 [7,8,9] 中访问索引为1的元素,即第二个位置上的元素,也就是8。
四、列表的常用操作(方法)
在Python中,函数是一个封装的代码单元,可以提供特定功能。如果将函数定义为类(class)中的成员时,这个函数就称为方法(method),表示它与该类相关联,可以通过该类的实例来调用和使用。
方法和函数功能一样, 有传入参数,有返回值,只是方法的使用格式不同:
- 函数的调用:
变量 = 函数(参数) - 方法的调用:
①创建类的实例:
student = Student()
②调用方法:
实例名.方法名(参数)
num = student.add(x, y)
# 函数
def add(x,y):
result=x+y
return result
#函数的调用
num1=add(1,2)
print(num1)
class Student:
# 该函数 add 是类 Student 的成员,因此被称为方法
def add(self, x, y):
result = x + y
return result
# 方法的调用
student = Student()
num2 = student.add(1, 2)
print(num2)
输出结果:
3
3
列表的常用方法:
①查找元素下标:
查找指定元素在列表的下标,如果找不到,则报错ValueError。
语法:列表.index(元素)
index就是列表对象(变量)内置的方法(函数)
#查找某元素在列表内的下标索引
mylist=["A","B","C"]
index=mylist.index("A")
print(f"A在列表中的下标索引值为{index}")
# 错误示范:如果查找的元素不存在,会报错 ValueError: 'D' is not in list
# index=mylist.index("D")
# print(f"D在列表中的下标索引值为{index}")
输出结果:
A在列表中的下标索引值为0
②插入元素:
在指定的下标位置插入指定的元素。
语法:列表.insert(下标, 元素)
# 在指定下标位置插入新的元素
mylist=["A","B","C"]
mylist.insert(1,"E")
print(f"列表插入元素后,结果为{mylist}")
输出结果:
列表插入元素后,结果为[‘A’, ‘E’, ‘B’, ‘C’]
③追加元素:
方式一:将指定元素,追加到列表的尾部
语法:列表.append(元素)
# 在列表尾部追加单个新元素
mylist=["A","B","C"]
mylist.append("F")
print(f"列表在尾部追加单个元素后,结果为{mylist}")
输出结果:
列表在尾部追加单个元素后,结果为[‘A’, ‘B’, ‘C’, ‘F’]
方式二:将其它数据容器的内容取出,依次追加到列表尾部
语法:列表.extend(其它数据容器)
# 在列表的尾部追加一批新元素
mylist=["A","B","C"]
mylist2=[1,2,3]
mylist.extend(mylist2)
print(f"列表在尾部追加一批元素后,结果为{mylist}")
输出结果:
列表在尾部追加一批元素后,结果为[‘A’, ‘B’, ‘C’, 1, 2, 3]
④删除元素:
方式一:删除指定下标索引的元素
语法:del 列表[下标]
# 方式一:del 列表[下标]
mylist=["A","B","C"]
del mylist[2]
print(f"列表删除元素后,结果为{mylist}")
输出结果:
列表删除元素后,结果为[‘A’, ‘B’]
该方式直接使用 del 关键字,不返回任何值,只是删除指定下标位置的元素。如果指定的下标超出了列表的范围,会引发 IndexError 异常。
方式二:删除指定下标索引的元素
语法:列表.pop(下标)
mylist=["A","B","C"]
element=mylist.pop(2)
print(f"通过pop方法取出元素后,结果为{mylist},取出的元素为{element}")
输出结果:
通过pop方法取出元素后,结果为[‘A’, ‘B’],取出的元素为C
该方式通过下标来删除列表中的元素,并返回被删除的元素。如果不指定下标,默认会删除并返回列表中的最后一个元素。如果指定的下标超出了列表的范围,会引发 IndexError 异常。
方式三:删除某元素在列表中的第一个匹配项
语法:列表.remove(元素)
# 删除某元素在列表中的第一个匹配项
mylist=["A","B","A","C"]
mylist.remove("A")
print(f",结果为{mylist}")
输出结果:
通过pop方法取出元素后,结果为[‘B’, ‘A’, ‘C’]
该方式不返回任何值。如果列表中不存在要删除的元素,会引发 ValueError 异常。
⑤修改元素
修改特定位置(索引)的元素值。
语法:列表[下标] = 值
直接对指定下标(正向、反向下标均可)的值进行重新赋值(修改)
# 修改特定下标索引的值
mylist=["A","B","C"]
mylist[0]="D"
print(f"列表被修改元素后,结果为{mylist}")
输出结果
列表被修改元素后,结果为[‘D’, ‘B’, ‘C’]
⑥统计元素个数:
方式一:统计列表内某元素的数量
语法:列表.count(元素)
mylist=["A","B","A","C"]
count=mylist.count("A")
print(f"列表中字母A的数量为{count}")
输出结果:
列表中字母A的数量为2
方式二:统计列表中全部元素的数量
语法:len(列表)
# 统计列表中全部元素的数量
mylist=["A","B","A","C"]
count=len(mylist)
print(f"列表的元素数量为{count}")
输出结果:
列表的元素数量为4
⑦清空列表:
清空列表内容。
语法:列表.clear()
# 清空列表内容
mylist=["A","B","C"]
mylist.clear()
print(f"列表被清空后,结果为{mylist}")
输出结果:
列表被清空后,结果为[]
【例题】
有一个列表,内容是:[21, 25, 21, 23, 22, 20],记录的是一批学生的年龄。请通过列表的功能(方法),按顺序对其进行如下操作:
1.定义这个列表,并用变量接收它
2.追加一个数字31,到列表的尾部
3.追加一个新列表[29, 33, 30],到列表的尾部
4.取出第一个元素(应是:21)
5.取出最后一个元素(应是:30)
6.查找元素31,在列表中的下标位置
age_list=[21,25,21,23,22,20]
print(f"列表为{age_list}")
age_list.append(31)
print(f"追加数字31到列表尾部后,列表为{age_list}")
list2=[29,33,30]
age_list.extend(list2)
print(f"追加一个新列表到列表尾部后,列表为{age_list}")
element1=age_list[0]
print(f"从列表中取出第一个元素:{element1}")
element2=age_list[-1]
print(f"从列表中取出最后一个元素:{element2}")
index=age_list.index(31)
print(f"元素31在列表的下标位置:{index}")
输出结果:
列表为[21, 25, 21, 23, 22, 20]
追加数字31到列表尾部后,列表为[21, 25, 21, 23, 22, 20, 31]
追加一个新列表到列表尾部后,列表为[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]
从列表中取出第一个元素:21
从列表中取出最后一个元素:30
元素31在列表的下标位置:6
五、列表的遍历
既然数据容器可以存储多个元素,那么就会有需求从容器内依次取出元素进行操作。将容器内的元素依次取出进行处理的行为称为“遍历”或者“迭代”。
①while循坏遍历:
定义一个变量表示下标,从0开始。
循环条件为:下标值 < 列表的元素数量
基本语法:
index = 0
while index < len(列表):
元素 = 列表[index]
对元素进行处理
index += 1
def list_while_func():
"""
使用while循坏遍历列表的演示函数
:return: None
"""
my_list=["A","B","C"]
# 定义一个变量用来标记列表的下标,初始值为0
index=0
# 循坏条件:下标索引变量<列表的元素数量
while index<len(my_list):
# 通过index变量取出对应下标的元素
element=my_list[index]
print(element)
# 将循环变量(index)每一次循环将下标索引+1
index+=1
#调用函数
list_while_func()
输出结果:
A
B
C
②for循坏遍历:
从容器内,依次取出元素并赋值到临时变量上。在每一次的循环中,我们可以对临时变量(元素)进行处理。
基本语法:
for 临时变量 in 数据容器:
对临时变量进行处理
def list_for_func():
"""
使用for循坏遍历列表的演示函数
:return: None
"""
my_list=["A","B","C"]
for element in my_list:
print(element)
#调用函数
list_for_func()
输出结果:
A
B
C
for循环和while循坏遍历对比:
- for循环更简单,while更灵活
- for循环适用于,遍历数据容器的场景或简单的固定次数循环场景;while循环适用于任何想要循环的场景