在 Python 中，列表（List）和元组（Tuple）是处理有序数据的核心工具。二者均能存储多类型元素，但 “可变性” 的差异决定了它们的适用场景。今天这篇指南，不仅讲清基础概念，更带你用代码实操关键功能，看完就能用！

一、列表（List）：可变的 “数据操作库”

1. 基础概念

• 本质：可变序列（创建后可自由增删改元素）

• 标识：用 [] 包裹元素，元素间用逗号分隔

• 特点：有序、支持嵌套、可存任意数据类型（数字、字符串、列表等）

2. 基础操作实操（代码可直接运行）

# 1. 创建列表（空列表/普通列表/嵌套列表）

my_list = [] # 空列表

num_list = [1, 2, 3] # 数字列表

mix_list = [1, 'a', [4, 5]] # 混合嵌套列表

# 2. 访问元素（索引从0开始，支持反向索引[-1]）

print(num_list[0]) # 输出：1（正向取第1个元素）

print(mix_list[-1]) # 输出：[4,5]（反向取最后1个元素）

# 3. 修改元素（直接通过索引赋值）

num_list[1] = 20 # 将第2个元素从2改为20

print(num_list) # 输出：[1, 20, 3]

# 4. 删除元素（用del关键字删指定索引元素）

del mix_list[2] # 删除索引为2的嵌套列表

print(mix_list) # 输出：[1, 'a']

3. 常用函数全解析（带代码示例）

（1）添加元素

函数	功能	代码示例	运行结果
append()	末尾添加 1 个元素	lst = [1,2]; lst.append(3)	[1,2,3]
extend()	末尾添加多个元素（可迭代对象）	lst.extend([4,5])	[1,2,3,4,5]
insert()	指定索引插入元素	lst.insert(1, 'a')	[1, 'a', 2, 3, 4, 5]

# 实际运行代码

lst = [1, 2]

lst.append(3)

lst.extend([4, 5])

lst.insert(1, 'a')

print(lst) # 输出：[1, 'a', 2, 3, 4, 5]

（2）删除元素

函数	功能	代码示例	运行结果
remove()	删除第一个匹配元素	lst = [1,2,3,2]; lst.remove(2)	[1,3,2]
pop()	删除并返回指定索引元素（默认末尾）	popped = lst.pop(1)	popped=3，lst=[1,2]
clear()	清空列表	lst.clear()	[]

# 实际运行代码

lst = [1, 2, 3, 2]

lst.remove(2)

popped = lst.pop(1)

lst.clear()

print(lst) # 输出：[]

print(popped) # 输出：3

（3）查找与统计

lst = ['a', 'b', 'c', 'a']

print(lst.index('c')) # 输出：2（返回元素首次出现的索引）

print(lst.count('a')) # 输出：2（统计元素出现次数）

print('b' in lst) # 输出：True（检测元素是否存在）

（4）排序与反转

lst = [3, 1, 4]

lst.sort() # 原地升序排序 → [1, 3, 4]

lst.reverse() # 原地反转 → [4, 3, 1]

new_lst = sorted(lst) # 生成新排序列表，原列表不变

print(lst) # 输出：[4, 3, 1]

print(new_lst) # 输出：[1, 3, 4]

（5）其他实用操作

lst = [5, 2, 8]

print(len(lst)) # 输出：3（获取列表长度）

print(max(lst)) # 输出：8（取最大值）

print(sum(lst)) # 输出：15（对数值列表求和）

二、元组（Tuple）：不可变的 “数据保险箱”

1. 基础概念

• 本质：不可变序列（创建后无法修改、删除、添加元素）

• 标识：用 () 包裹元素，单元素必须加逗号（如 (7,)，否则视为普通括号）

• 特点：有序、支持嵌套、内存占用小、访问速度快，可作为字典键

2. 基础操作实操

# 1. 创建元组（空元组/普通元组/单元素元组/列表转元组）

empty_tuple = () # 空元组

normal_tuple = (1, 2, 'x')# 普通元组

single_tuple = (7,) # 单元素元组（必加逗号）

from_list = tuple([4,5]) # 从列表转换为元组

# 2. 访问元素（同列表，支持索引和切片）

print(normal_tuple[2]) # 输出：'x'（取索引2的元素）

print(from_list[0:2]) # 输出：(4,5)（切片取元素）

# 3. 尝试修改会报错（不可变性核心体现）

# normal_tuple[1] = 20 # 执行会抛出：TypeError（禁止修改）

3. 元组专属常用操作

# 1. 拼接（用+合并多个元组，生成新元组）

t1 = (1, 2)

t2 = (3, 4)

print(t1 + t2) # 输出：(1, 2, 3, 4)

# 2. 重复（用*复制元素，生成新元组）

t3 = ('x',)

print(t3 * 3) # 输出：('x', 'x', 'x')

# 3. 成员检测（用in判断元素是否存在）

t4 = (10, 20, 30)

print(20 in t4) # 输出：True

三、列表与元组核心差异速查表

对比维度	列表（List）	元组（Tuple）
标识符号	[]	()
可变性	支持增删改	完全不可变
字典键适用性	不可（无哈希性）	可（有哈希性）
内存 / 速度	占用大、访问慢	占用小、访问快
核心场景	动态数据（购物车、日志）	固定数据（配置、坐标）

跟着代码跑一遍，列表和元组的用法就能轻松掌握！