Chapter 08 Python数据容器：列表

欢迎大家订阅【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循环适用于任何想要循环的场景