第二章：Python3 之列表与元组

文章目录：

前言

[1. 列表与元组概述](#1. 列表与元组概述)

[1.1 什么是序列？](#1.1 什么是序列？)

[1.2 什么是列表（list）？](#1.2 什么是列表（list）？)

[1.3 什么是元组（tuple）？](#1.3 什么是元组（tuple）？)

[1.4 核心图解：列表 vs 元组](#1.4 核心图解：列表 vs 元组)

[2. 通用序列操作（列表 + 元组共用）](#2. 通用序列操作（列表 + 元组共用）)

[2.1 索引访问（通过位置获取元素）](#2.1 索引访问（通过位置获取元素）)

[2.2 切片操作（获取子序列）](#2.2 切片操作（获取子序列）)

[2.3 序列拼接（+）](#2.3 序列拼接（+）)

[2.4 序列重复（*）](#2.4 序列重复（*）)

[2.5 成员判断（in /not in）](#2.5 成员判断（in /not in）)

[2.6 长度计算（len ()）](#2.6 长度计算（len ()）)

[2.7 最大值、最小值（max () /min ()）](#2.7 最大值、最小值（max () /min ()）)

[2.8 元素求和（sum ()）](#2.8 元素求和（sum ()）)

[3. 列表（list）详解](#3. 列表（list）详解)

[3.1 列表的定义与创建](#3.1 列表的定义与创建)

[3.1.1 直接创建（最常用）](#3.1.1 直接创建（最常用）)

[3.1.2 使用 list () 函数创建](#3.1.2 使用 list () 函数创建)

[3.2 更新列表](#3.2 更新列表)

[3.3 元素赋值](#3.3 元素赋值)

[3.4 增加元素](#3.4 增加元素)

[3.4.1 append ()：末尾追加单个元素](#3.4.1 append ()：末尾追加单个元素)

[3.4.2 extend ()：末尾追加多个元素（合并列表）](#3.4.2 extend ()：末尾追加多个元素（合并列表）)

[3.4.3 insert ()：指定位置插入元素](#3.4.3 insert ()：指定位置插入元素)

[3.5 删除元素](#3.5 删除元素)

[3.5.1 del：删除指定索引 / 整个列表](#3.5.1 del：删除指定索引 / 整个列表)

[3.5.2 pop ()：删除指定索引元素并返回（默认最后一个）](#3.5.2 pop ()：删除指定索引元素并返回（默认最后一个）)

[3.5.3 remove ()：删除第一个匹配的元素](#3.5.3 remove ()：删除第一个匹配的元素)

[3.5.4 clear ()：清空列表](#3.5.4 clear ()：清空列表)

[3.6 分片赋值](#3.6 分片赋值)

[3.7 嵌套列表](#3.7 嵌套列表)

[3.8 列表常用方法](#3.8 列表常用方法)

[4. 元组（tuple）详解](#4. 元组（tuple）详解)

[4.1 元组的定义与创建](#4.1 元组的定义与创建)

[4.1.1 直接创建](#4.1.1 直接创建)

[4.1.2 省略括号创建](#4.1.2 省略括号创建)

[4.2 tuple () 函数](#4.2 tuple () 函数)

[4.3 元组基本操作](#4.3 元组基本操作)

[4.4 访问元组](#4.4 访问元组)

[4.5 修改元组](#4.5 修改元组)

[4.6 删除元组](#4.6 删除元组)

[4.7 元组索引和截取](#4.7 元组索引和截取)

[4.8 元组内置函数](#4.8 元组内置函数)

[5. 列表与元组的核心区别](#5. 列表与元组的核心区别)

[6. 列表与元组的互相转化](#6. 列表与元组的互相转化)

[7. 列表与元组实战项目](#7. 列表与元组实战项目)

[7.1 实战 1：运维日志数据统计](#7.1 实战 1：运维日志数据统计)

[7.2 实战 2：后端接口参数校验](#7.2 实战 2：后端接口参数校验)

[7.3 实战 3：AI 数据预处理](#7.3 实战 3：AI 数据预处理)

[7.4 实战 4：前端数据格式化处理](#7.4 实战 4：前端数据格式化处理)

写在最后的话：

前言

在 Python 编程世界中，序列是最基础且核心的数据结构，而列表（list） 和元组（tuple） 则是序列中最常用的两种类型。无论是前端数据处理、后端业务逻辑、运维脚本编写，还是 AI 算法的数据预处理，都离不开列表与元组的支撑。

本文将从零基础出发，系统讲解列表与元组的核心概念、通用操作、高级用法、区别联系，并搭配实战项目，帮助你彻底掌握这两种数据结构，写出高效、简洁、健壮的 Python 代码。全文覆盖基础语法、进阶技巧、实战场景，适配初级到中级开发者，以及前端、后端、运维、AI 爱好者等不同人群。

1. 列表与元组概述

1.1 什么是序列？

在 Python 中，序列是按照一定顺序排列的可迭代对象，元素可以通过索引访问。列表和元组都属于序列，它们支持索引、切片、遍历、拼接等通用操作。

1.2 什么是列表（list）？

定义：列表是 Python 中最常用的可变有序序列 ，使用方括号 [] 表示。

特点：可修改、可增删元素、可存储不同数据类型、有序、支持嵌套。

适用场景：需要频繁修改的数据集合（如动态数据、临时存储、业务数据处理）。

示例代码：

python 复制代码

# 定义一个列表，包含整数、字符串、布尔值、浮点数
my_list = [1, "Python", True, 3.14, [2, 3]]
# 打印列表和类型
print("列表内容：", my_list)
print("列表类型：", type(my_list))

运行结果：

复制代码

列表内容： [1, 'Python', True, 3.14, [2, 3]]
列表类型： <class 'list'>

1.3 什么是元组（tuple）？

定义：元组是 Python 中不可变有序序列 ，使用圆括号 () 表示。

特点：不可修改、不可增删元素、可存储不同数据类型、有序、支持嵌套。

适用场景：数据不允许修改的场景（如配置参数、函数返回值、常量定义）。

示例代码：

复制代码

# 定义一个元组，包含多种数据类型
my_tuple = (1, "Python", True, 3.14, (2, 3))
# 打印元组和类型
print("元组内容：", my_tuple)
print("元组类型：", type(my_tuple))

运行结果：

复制代码

元组内容： (1, 'Python', True, 3.14, (2, 3))
元组类型： <class 'tuple'>

1.4 核心图解：列表 vs 元组

python 复制代码

┌─────────────────────────────────────────────┐
│                序列（Sequence）               │
├─────────────────┬───────────────────────────┤
│   列表（list）   |        元组（tuple）        │
├─────────────────┼───────────────────────────┤
│    符号：[]     │          符号：()           │
│     可变        │           不可变            │
│  增删改查均支持  │      仅支持查，不支持改删      │
│  占用内存稍大    │      占用内存更小、效率更高    │
└─────────────────┴───────────────────────────┘

2. 通用序列操作（列表 + 元组共用）

列表和元组都属于序列，因此支持完全相同的通用操作，包括索引、切片、拼接、重复、成员判断、长度计算、最大值 / 最小值等。

2.1 索引访问（通过位置获取元素）

序列中的元素从左到右，索引从 0 开始；从右到左，索引从 -1 开始。

语法： 序列[索引值]

示例代码：

python 复制代码

# 定义列表和元组
num_list = [10, 20, 30, 40, 50]
num_tuple = (10, 20, 30, 40, 50)

# 1. 正索引访问（从左到右）
print("列表第1个元素：", num_list[0])   # 输出10
print("元组第3个元素：", num_tuple[2])  # 输出30

# 2. 负索引访问（从右到左）
print("列表最后1个元素：", num_list[-1])   # 输出50
print("元组倒数第2个元素：", num_tuple[-2])# 输出40

2.2 切片操作（获取子序列）

切片可以一次性获取序列中的多个元素，语法：序列[起始索引:结束索引:步长]

起始索引：包含，默认 0

结束索引：不包含，默认序列长度

步长：默认 1，正数从左到右，负数从右到左

示例代码：

python 复制代码

# 定义序列
seq = [1,2,3,4,5,6,7,8,9]

# 1. 基础切片：获取索引1-4的元素（不包含5）
print(seq[1:5])   # [2,3,4,5]

# 2. 省略起始索引：从开头到索引4
print(seq[:5])    # [1,2,3,4,5]

# 3. 省略结束索引：从索引3到结尾
print(seq[3:])    # [4,5,6,7,8,9]

# 4. 步长为2：隔一个取一个
print(seq[::2])   # [1,3,5,7,9]

# 5. 反转序列
print(seq[::-1])  # [9,8,7,6,5,4,3,2,1]

2.3 序列拼接（+）

使用 + 可以将两个同类型序列拼接成一个新序列。

示例代码：

python 复制代码

# 列表拼接
list1 = [1,2]
list2 = [3,4]
print(list1 + list2)  # [1,2,3,4]

# 元组拼接
tuple1 = (1,2)
tuple2 = (3,4)
print(tuple1 + tuple2) # (1,2,3,4)

2.4 序列重复（*）

使用 * 可以将序列重复指定次数，生成新序列。

示例代码：

复制代码

# 列表重复3次
print([1,2] * 3)  # [1,2,1,2,1,2]

# 元组重复2次
print((1,2) * 2)  # (1,2,1,2)

2.5 成员判断（in /not in）

判断元素是否存在于序列中，返回布尔值。

示例代码：

python 复制代码

my_list = [10,20,30]
my_tuple = (10,20,30)

print(20 in my_list)    # True
print(40 not in my_tuple) # True

2.6 长度计算（len ()）

获取序列中元素的个数。

示例代码：

python 复制代码

print(len([1,2,3,4]))  # 4
print(len((1,2,3)))    # 3

2.7 最大值、最小值（max () /min ()）

获取序列中元素的最大值和最小值（要求元素可比较）。

示例代码：

python 复制代码

num = [5,1,9,3]
print(max(num))  # 9
print(min(num))  # 1

2.8 元素求和（sum ()）

对数字类型序列求和。

示例代码：

python 复制代码

print(sum([1,2,3,4]))  # 10

3. 列表（list）详解

列表是可变序列，这是它与元组最大的区别。我们可以对列表进行增、删、改、查等所有操作。

3.1 列表的定义与创建

3.1.1 直接创建（最常用）

python 复制代码

# 空列表
empty_list = []
# 带元素的列表
num_list = [1,2,3]
# 混合类型列表
mix_list = [1, "a", True, None]

3.1.2 使用 list () 函数创建

python 复制代码

# 从字符串创建列表
str_list = list("Python")
print(str_list)  # ['P','y','t','h','o','n']

# 从元组创建列表
t = (1,2,3)
new_list = list(t)
print(new_list)  # [1,2,3]

3.2 更新列表

直接通过索引修改列表中的元素。

示例代码：

python 复制代码

# 定义列表
fruits = ["苹果", "香蕉", "橙子"]
# 修改索引1的元素
fruits[1] = "葡萄"
print(fruits)  # ['苹果', '葡萄', '橙子']

3.3 元素赋值

支持批量赋值、索引赋值、切片赋值。

示例代码：

python 复制代码

num = [1,2,3,4,5]
# 1. 单个元素赋值
num[0] = 100

# 2. 切片批量赋值
num[1:3] = [200, 300]
print(num)  # [100,200,300,4,5]

3.4 增加元素

列表提供 4 种常用方式增加元素：append()、extend()、insert()、+ 拼接。

3.4.1 append ()：末尾追加单个元素

python 复制代码

list1 = [1,2]
list1.append(3)
print(list1)  # [1,2,3]

3.4.2 extend ()：末尾追加多个元素（合并列表）

python 复制代码

list1 = [1,2]
list1.extend([3,4])
print(list1)  # [1,2,3,4]

3.4.3 insert ()：指定位置插入元素

python 复制代码

list1 = [1,3]
list1.insert(1, 2)  # 在索引1的位置插入2
print(list1)  # [1,2,3]

3.5 删除元素

列表提供 4 种删除方式：del、pop()、remove()、clear()。

3.5.1 del：删除指定索引 / 整个列表

python 复制代码

num = [1,2,3,4]
del num[1]  # 删除索引1的元素
print(num)  # [1,3,4]

3.5.2 pop ()：删除指定索引元素并返回（默认最后一个）

python 复制代码

num = [1,2,3]
val = num.pop()  # 删除最后一个元素，返回3
print(num)  # [1,2]
print(val)  # 3

3.5.3 remove ()：删除第一个匹配的元素

python 复制代码

num = [1,2,2,3]
num.remove(2)  # 删除第一个2
print(num)  # [1,2,3]

3.5.4 clear ()：清空列表

python 复制代码

num = [1,2,3]
num.clear()
print(num)  # []

3.6 分片赋值

分片赋值是列表的高级特性，可以替换、插入、删除列表中的一段元素，无需考虑长度匹配。

示例代码：

python 复制代码

# 1. 替换元素
num = [1,2,3,4]
num[1:3] = [20,30]
print(num)  # [1,20,30,4]

# 2. 插入元素（起始=结束索引）
num[2:2] = [25]
print(num)  # [1,20,25,30,4]

# 3. 删除元素
num[1:3] = []
print(num)  # [1,30,4]

3.7 嵌套列表

列表中可以包含另一个列表，形成二维 / 多维列表，常用于矩阵、表格数据。

示例代码：

python 复制代码

# 二维列表（3行3列）
matrix = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]

# 访问第二行第三列元素
print(matrix[1][2])  # 6

# 修改嵌套列表元素
matrix[0][0] = 100
print(matrix)

3.8 列表常用方法

方法	作用
list.append(x)	末尾追加元素
list.extend(iterable)	追加可迭代对象
list.insert(i,x)	指定位置插入
list.pop(i)	删除并返回指定索引元素
list.remove(x)	删除第一个匹配元素
list.clear()	清空列表
list.index(x)	返回元素第一个索引
list.count(x)	统计元素出现次数
list.sort()	原地排序
list.reverse()	原地反转
list.copy()	浅拷贝列表

完整示例代码：

python 复制代码

# 初始化列表
nums = [3,1,4,1,5,9]

# 1. index()：查找元素索引
print(nums.index(4))  # 2

# 2. count()：统计次数
print(nums.count(1))  # 2

# 3. sort()：升序排序
nums.sort()
print(nums)  # [1,1,3,4,5,9]

# 4. reverse()：反转
nums.reverse()
print(nums)  # [9,5,4,3,1,1]

# 5. copy()：拷贝列表
new_nums = nums.copy()
print(new_nums)

4. 元组（tuple）详解

元组是不可变序列 ，一旦创建就不能修改、添加、删除元素，这是它的核心特性。

4.1 元组的定义与创建

4.1.1 直接创建

python 复制代码

# 空元组
empty_tuple = ()

# 带元素的元组
t1 = (1,2,3)

# 单元素元组（必须加逗号！）
t2 = (1,)  # 正确
t3 = (1)   # 错误，这是整数1

4.1.2 省略括号创建

python 复制代码

t = 1,2,3  # 等价于 (1,2,3)

4.2 tuple () 函数

将可迭代对象（列表、字符串、集合等）转换为元组。

示例代码：

python 复制代码

# 列表转元组
print(tuple([1,2,3]))  # (1,2,3)

# 字符串转元组
print(tuple("abc"))  # ('a','b','c')

4.3 元组基本操作

元组仅支持查询类操作，不支持修改类操作。

4.4 访问元组

通过索引、切片访问，与列表完全一致。

示例代码：

python 复制代码

t = (10,20,30,40)
print(t[0])    # 10
print(t[1:3])  # (20,30)

4.5 修改元组

元组本身不可修改，但如果元组中包含可变对象（如列表），则可变对象可以修改。

示例代码：

python 复制代码

# 元组中包含列表
t = (1, [2,3], 4)
# 修改元组中的列表元素
t[1][0] = 200
print(t)  # (1, [200, 3], 4)

4.6 删除元组

元组元素不能删除，但可以删除整个元组变量。

示例代码：

python 复制代码

t = (1,2,3)
del t  # 删除整个元组
# print(t)  # 报错，变量已不存在

4.7 元组索引和截取

与列表完全一致，支持正索引、负索引、切片。

4.8 元组内置函数

元组支持的内置函数：

len(tuple)：长度

max(tuple)：最大值

min(tuple)：最小值

tuple(iterable)：转换为元组

sum(tuple)：求和

示例代码：

python 复制代码

t = (5,1,9,3)
print(len(t))   # 4
print(max(t))   # 9
print(min(t))   # 1
print(sum(t))   # 18

5. 列表与元组的核心区别

对比维度	列表（list）	元组（tuple）
定义符号	`[]`	`()`
可变性	可变（增删改）	不可变
性能	内存占用大，效率较低	内存占用小，效率更高
方法	方法丰富（append/pop 等）	方法极少（仅 count/index）
哈希性	不可哈希	可哈希（可作为字典键）
使用场景	动态数据、频繁修改	静态数据、配置参数、常量
语法陷阱	无	单元素必须加逗号

核心总结：

需要修改数据 → 用列表

数据不允许修改 → 用元组

追求性能和安全 → 优先元组

6. 列表与元组的互相转化

Python 提供内置函数实现两者无缝转换：

列表 → 元组：tuple(列表)
元组 → 列表：list(元组)

示例代码：

python 复制代码

# 列表转元组
my_list = [1,2,3]
my_tuple = tuple(my_list)
print(type(my_tuple))  # <class 'tuple'>

# 元组转列表
my_tuple2 = (4,5,6)
my_list2 = list(my_tuple2)
print(type(my_list2))  # <class 'list'>

7. 列表与元组实战项目

7.1 实战 1：运维日志数据统计

场景：运维人员需要统计服务器日志中的错误码出现次数。

技术点：列表存储日志、count () 统计、元组存储固定错误码。

python 复制代码

# 服务器日志（列表存储，动态数据）
log_codes = [404, 500, 200, 404, 500, 200, 404, 301]
# 固定错误类型（元组存储，不可修改）
error_codes = (404, 500, 301)

# 统计错误码次数
print("=== 日志错误统计 ===")
for code in error_codes:
    count = log_codes.count(code)
    print(f"错误码 {code} 出现次数：{count}")

运行结果：

复制代码

=== 日志错误统计 ===
错误码 404 出现次数：3
错误码 500 出现次数：2
错误码 301 出现次数：1

7.2 实战 2：后端接口参数校验

场景：后端接口接收前端参数，校验参数是否在允许范围内。

技术点：元组存储允许参数、列表接收请求参数。

复制代码

# 允许的用户角色（元组，不可篡改）
ALLOW_ROLES = ("admin", "user", "guest")
# 前端传入的参数（列表）
req_params = ["admin", "test", "user"]

# 参数校验
print("=== 接口参数校验 ===")
for param in req_params:
    if param in ALLOW_ROLES:
        print(f"参数 {param}：校验通过")
    else:
        print(f"参数 {param}：非法参数")

7.3 实战 3：AI 数据预处理

场景：AI 模型训练前，将原始数据转换为固定格式的元组（保证数据不被篡改）。

技术点：列表存储原始数据、转换元组、切片提取特征。

python 复制代码

# 原始数据集（列表）
raw_data = [
    [180, 75, "male"],
    [165, 55, "female"],
    [175, 65, "male"]
]

# 转换为元组（固定数据）
dataset = tuple(raw_data)
print("=== AI训练数据集 ===")
print(dataset)

# 提取身高特征（切片）
heights = [data[0] for data in dataset]
print("身高特征：", heights)

7.4 实战 4：前端数据格式化处理

场景：前端接收后端返回的列表数据，格式化为展示用的元组数据。

技术点：列表拼接、元组转换、数据格式化。

python 复制代码

# 后端返回的商品数据（列表）
goods = ["手机", "电脑", "平板"]
prices = [3999, 5999, 2999]

# 拼接数据并转换为元组（前端展示用）
format_data = tuple(zip(goods, prices))
print("=== 前端展示数据 ===")
for name, price in format_data:
    print(f"商品：{name}，价格：{price}元")

写在最后的话：

列表与元组是 Python 编程的基石，贯穿所有开发场景。本文从基础概念、通用操作、高级用法、实战项目全方位讲解了列表与元组的核心知识：

列表：可变、灵活，适合动态数据处理

元组：不可变、高效，适合静态数据存储

通用序列操作：索引、切片、拼接、成员判断

实战应用：运维、后端、AI、前端全场景覆盖

熟练掌握列表与元组，是你成为 Python 高效开发者的第一步。后续可结合字典、集合、函数等知识，构建更复杂的程序逻辑。

🙌 感谢你读到这里！

🔍 技术之路没有捷径，但每一次阅读、思考和实践，都在悄悄拉近您与目标的距离。

💡 如果本文对你有帮助，不妨 👍 点赞、📌 收藏、📤 分享给更多需要的朋友！

💬 欢迎在评论区留下你的想法、疑问或建议，我会一一回复，我们一起交流、共同成长 🌿

🔔 关注我，不错过下一篇干货！我们下期再见！✨

第二章：Python3 之 列表与元组

前言

1. 列表与元组概述

1.1 什么是序列？

1.2 什么是列表（list）？

1.3 什么是元组（tuple）？

1.4 核心图解：列表 vs 元组

2. 通用序列操作（列表 + 元组共用）

2.1 索引访问（通过位置获取元素）

2.2 切片操作（获取子序列）

2.3 序列拼接（+）

2.4 序列重复（*）

2.5 成员判断（in /not in）

2.6 长度计算（len ()）

2.7 最大值、最小值（max () /min ()）

2.8 元素求和（sum ()）

3. 列表（list）详解

3.1 列表的定义与创建

3.1.1 直接创建（最常用）

3.1.2 使用 list () 函数创建

3.2 更新列表

3.3 元素赋值

3.4 增加元素

3.4.1 append ()：末尾追加单个元素

3.4.2 extend ()：末尾追加多个元素（合并列表）

3.4.3 insert ()：指定位置插入元素

3.5 删除元素

3.5.1 del：删除指定索引 / 整个列表

3.5.2 pop ()：删除指定索引元素并返回（默认最后一个）

3.5.3 remove ()：删除第一个匹配的元素

3.5.4 clear ()：清空列表

3.6 分片赋值

3.7 嵌套列表

3.8 列表常用方法

4. 元组（tuple）详解

4.1 元组的定义与创建

4.1.1 直接创建

4.1.2 省略括号创建

4.2 tuple () 函数

4.3 元组基本操作

4.4 访问元组

4.5 修改元组

4.6 删除元组

4.7 元组索引和截取

4.8 元组内置函数

5. 列表与元组的核心区别

6. 列表与元组的互相转化

7. 列表与元组实战项目

7.1 实战 1：运维日志数据统计

7.2 实战 2：后端接口参数校验

7.3 实战 3：AI 数据预处理

7.4 实战 4：前端数据格式化处理

写在最后的话：

第二章：Python3 之列表与元组