代码收藏家 Python列表操作指南：常用方法与内置函数速览表
Python 列表常用方法与python操纵列表的内置函数速查表
1. Python 常用方法表
| 方法名 | 英文含义 | 中文作用 | 参数类型 | 示例 | 返回值 | 是否修改原列表 | 说明备注 |
|---|---|---|---|---|---|---|---|
append(x) |
append = 附加 | 在列表末尾添加一个元素 | 元素 | lst.append(4) |
None |
✅ 是 | 增加一个元素到末尾 |
extend(iterable) |
extend = 拓展 | 把一个可迭代对象的所有元素添加到列表 | 可迭代对象 | lst.extend([5, 6]) |
None |
✅ 是 | 类似多个 append |
insert(i, x) |
insert = 插入 | 在指定位置插入一个元素 | 索引 + 元素 | lst.insert(2, 99) |
None |
✅ 是 | 插入到索引 i 之前 |
remove(x) |
remove = 删除 | 删除列表中第一个等于 x 的元素 |
元素 | lst.remove(3) |
None |
✅ 是 | 如果不存在会报错 |
pop([i]) |
pop = 弹出 | 删除并返回索引为 i 的元素（默认最后） |
索引（可选） | lst.pop() / lst.pop(0) |
被删除的值 | ✅ 是 | 索引越界会报错 |
clear() |
clear = 清空 | 清空列表中所有元素 | 无 | lst.clear() |
None |
✅ 是 | 变成空列表 |
index(x[, start[, end]]) |
index = 查索引 | 返回指定元素第一次出现的索引 | 元素 + 范围（可选） | lst.index(3) |
int 索引 | ❌ 否 | 不存在会报错 |
count(x) |
count = 计数 | 统计某个元素出现的次数 | 元素 | lst.count(2) |
int 次数 | ❌ 否 | 用于频率统计 |
sort(key=None, reverse=False) |
sort = 排序 | 对列表原地排序 | 可选参数 | lst.sort() / lst.sort(reverse=True) |
None |
✅ 是 | 不返回新列表 |
reverse() |
reverse = 反转 | 原地将列表反转 | 无 | lst.reverse() |
None |
✅ 是 | 不排序，只逆序 |
copy() |
copy = 复制 | 返回一个列表浅拷贝 | 无 | new_lst = lst.copy() |
新列表 | ❌ 否 | 是浅拷贝，不修改原列表 |
示例代码
1.1 方法的参数和索引有关
#### 1.11 弹出元素（pop())
lst = [2, 3, 5, 6, 7, 8, 9, 10]
lst.pop() # pop默认弹出列表中最后一个元素 10
print(lst) # out: [2, 3, 5, 6, 7, 8, 9]
lst = [2, 3, 5, 6, 7, 8, 9, 10]
lst.pop(2) # 弹出列表中索引为2的元素 即元素5
print(lst) # out: [2, 3, 6, 7, 8, 9, 10]
lst = [2, 3, 5, 6, 7, 8, 9, 10]
a = lst.pop(3) # 弹出索引为3的元素(6)并传递给变量a
print(a) # out: 6
1.12 在特定位置插入元素 (insert())
lst = [2, 3, 5, 6, 7, 8, 9, 10]
lst.insert(2, 5) # 在索引为2的地方插入整型元素 5
print(lst) # out: [2, 3, 5, 5, 6, 7, 8, 9, 10]
1.2 方法的参数和元素有关
1.2.1 在列表末尾添加元素（append()）
lst = [2, 3, 5, 6, 7, 8, 9, 10]
lst.append(99) # 向lst尾部添加整型元素99
print(lst) # out : [2, 3, 5, 6, 7, 8, 9, 10, 99]
1.2.2 获取元素索引 （index()）
list_c = ["a", "b", "c","d"]
index_ = list_c.index("b") # 返回元素"b"的索引
print(index_) # out: 1
lst = ['a', 'b', 'c', 'b', 'd']
# 查找 'b' 第一次出现的位置
print(lst.index('b')) # 输出：1
# 从索引2开始查找 'b'
print(lst.index('b', 2)) # 输出：3
# 在索引2到4（不含4）之间查找 'b'
print(lst.index('b', 2, 4)) # 输出：3
# 如果元素不存在会报错
# print(lst.index('x')) # ValueError: 'x' is not in list
1.2.3 删除特定元素（remove()）
list_c.remove("c") # 将元素"c"从列表中删除
print(list_c) # out: ['a', 'b', 'd']
1.2.4 统计元素个数(count())
list_d = ['H','e','l','l','o']
count_ = list_d.count('l') # 统计元素在列表中的个数
print(count_) # out: 2
1.3 列表排序的方法
1.3.1 列表反转（reverse()）
lst = [2, 3, 5, 6, 7, 8, 9, 10]
lst.reverse() # 列表反转
print(lst) # out: [10, 9, 8, 7, 6, 5, 3, 2]
1.3.2 列表排序（sort()）
lst = [3, 2, 1, 4, 5, 6]
lst.sort() # 列表升序
print(lst) # out: [1, 2, 3, 4, 5, 6]
lst = [2, 3, 5, 6, 7, 8, 9, 10]
lst.sort(reverse=True) # 列表降序 当reverse=True时 列表降序 reverse=False时 列表升序
print(lst) # out: [10, 9, 8, 7, 6, 5, 3, 2]
1.4 其他方法
1.4.1 列表扩展（extend()）
list_c = ["a", "b", "c","d"]
list_c.extend(['f','g','h']) # 将两个列表合并
print(list_c) # ['a', 'b', 'c', 'd', 'f', 'g', 'h']
1.4.2 列表用方法拷贝（copy()）
# 列表拷贝
list_c = ["a", "b", "c","d"]
list_d = list_c.copy() # 浅拷贝 复制列表
print(list_d) # out: ['a', 'b', 'c', 'd']
2. 运算符与操作列表的python内置函数表
| 操作方式 | 说明 | 示例 | 返回值类型 | 结果说明 / 注意事项 |
|---|---|---|---|---|
切片 lst[start:end:step] |
获取列表的一部分 | lst[1:4] → [2, 3, 4] |
list |
不修改原列表，步长可为负 |
连接 + |
合并两个列表 | [1, 2] + [3, 4] → [1, 2, 3, 4] |
list |
返回新列表，原列表不变 |
重复 * |
重复列表内容 | [1, 2] * 3 → [1, 2, 1, 2, 1, 2] |
list |
创建新列表，原列表不变 |
成员判断 in |
判断元素是否在列表中 | 3 in [1, 2, 3] → True |
bool |
返回布尔值，表示是否存在 |
长度 len(lst) |
获取列表长度 | len([1, 2, 3]) → 3 |
int |
返回的是元素个数 |
最大值 max(lst) |
获取最大元素 | max([1, 3, 2]) → 3 |
元素的类型（如 int, str） |
所有元素必须可比较 |
最小值 min(lst) |
获取最小元素 | min([1, 3, 2]) → 1 |
元素的类型 | 同上 |
排序 sorted(lst) |
返回排序后的新列表 | sorted([3, 1, 2]) → [1, 2, 3] |
list |
原列表不变，可添加 reverse=True |
枚举 enumerate(lst) |
获取元素及其索引迭代器 | list(enumerate(['a', 'b'])) → [(0, 'a'), (1, 'b')] |
enumerate（可转为 list）使用list()转化 |
常配合 for 使用 |
zip zip(lst1, lst2) |
压缩多个可迭代对象 | list(zip([1,2],[3,4])) → [(1,3),(2,4)] |
zip（可转为 list）使用list()转化 |
按最短的序列配对 |
过滤 filter(func, lst) |
筛选满足条件的元素 | list(filter(lambda x:x>2,[1,2,3])) → [3] |
filter（可转为 list）使用list()转化 |
返回符合条件的新可迭代对象 |
映射 map(func, lst) |
对每个元素应用函数 | list(map(str, [1,2])) → ['1','2'] |
map（可转为 list）使用list()转化 |
不改变原列表 |
示例代码
2.1 切片
lst1 = [1, 2, 3, 4] # 初始列表
print(lst1[1:4]) # 切片 左闭右开 即[1,4)
# out:[2, 3, 4]
一. 运算符
2.2 连接 +
lst1 = [1, 2, 3, 4] # 初始列表
lst2 = lst1 + [5, 6, 7] # 将两个列表用运算符拼接
print(lst2) # out: [1, 2, 3, 4, 5, 6, 7]
2.3 重复 *
lst1 = [1, 2, 3, 4] # 初始列表
lst3 = lst1 * 3 # 重复
print(lst3) # out: [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
2.4 成员判断是否存在 in
lst1 = [1, 2, 3, 4] # 初始列表
print(3 in lst1) # 查看元素是否在列表中存在 out:True 如果没有返回False
二. Python内置函数操作列表
2.5 列表长度 len()
lst1 = [1, 2, 3, 4] # 初始列表
len_ = len(lst1) # 返回列表长度 type: int
print(len_) # out: 4
2.6 列表中的最大值max()和最小值 min()
lst1 = [1, 2, 3, 4] # 初始列表
max_ = max(lst1) # 获取列表中的最大值
print(max_) # out: 4
min_ = min(lst1) # 获取列表中的最小值
print(min_) # out: 1
2.7 排序 sorted()
lst1 = [4, 2, 1, 3] # 初始列表
lst2 = sorted(lst1) # 排序 默认reverse = False 默认升序(从小到大排序)
print(lst2) # out: [1, 2, 3, 4]
lst3 = sorted(lst1, reverse = True) # 降序排序(从大到小排序)
常用参数：
| 参数名 | 类型 | 说明 |
|---|---|---|
iterable |
可迭代对象 | 必填。任何可迭代对象，如列表、元组、字符串、字典（排序键）等 |
key |
函数或None |
选填。指定排序的“依据函数”，会对 iterable 中的每个元素应用该函数，按返回值排序 |
reverse |
布尔值 | 选填。默认 False，表示升序。设为 True 表示降序 |
key参数常见用法:
| 用法 | 示例 |
|---|---|
| 按长度排序 | key=len |
| 自定义函数 | key=lambda x: x[1] |
| 忽略大小写排序字符串 | key=str.lower |
| 按多个字段排序（使用元组） | key=lambda x: (x[1], x[0]) |
需要配合list()的python内置函数
2.8 枚举 enumerate()
语法：
enumerate(iterable, start=0)
# iterable：可迭代对象，如列表、字符串、元组等
# start：可选参数，指定索引起始值（默认从 0 开始）
- 示例代码
lst = ['a', 'b', 'c']
e = enumerate(lst)
print(e) # 输出：<enumerate object at 0x...>
print(list(e)) # 转换为列表：[(0, 'a'), (1, 'b'), (2, 'c')]
- 示例代码(配合for循环使用)
lst = ['a', 'b', 'c']
lst1 = []
for k,i in enumerate(lst):
lst1.append((k,i))
print(lst1) # out: [(0, 'a'), (1, 'b'), (2, 'c')]
2.9 打包 zip ()
lst1 = ['a', 'b', 'c']
lst2 = [1, 2, 3]
zip_ = zip(lst1, lst2)
print(list(zip_)) # out: [('a', 1), ('b', 2), ('c', 3)]
2.10 过滤 filter()
示例1 筛选满足条件的元素
def is_even(n):
return n % 2 == 0
numbers = [1, 2, 3, 4, 5, 6]
result = filter(is_even, numbers)
print(list(result)) # 输出: [2, 4, 6]
示例2：使用匿名函数过滤列表元素
numbers = [1, 2, 3, 4, 5, 6]
even = list(filter(lambda x: x % 2 == 0, numbers)) # 当 numbers 中的元素满足 lambda 函数返回 True 时，该元素会被保留下来，否则被过滤掉
print(even) # 输出: [2, 4, 6]
示例3. 筛掉空字符串
texts = ["apple", "", "banana", "", "cherry"]
non_empty = list(filter(None, texts))
print(non_empty) # 输出: ['apple', 'banana', 'cherry']
"""
说明：当 function=None 时，filter() 会自动过滤掉布尔值为 False 的元素（如 "", 0, None, False）。
"""
| 函数 | 作用 | 返回值类型 | 示例简述 |
|---|---|---|---|
filter(func, iterable) |
过滤满足条件的元素 | filter对象 |
filter(lambda x: x>0, lst) |
list(filter(...)) |
转换为列表以查看结果 | list |
list(filter(...)) |
2.11 映射 map()
基本语法:
map(function, iterable) # 它会将 function 作用于 iterable 的每一个元素，并返回一个迭代器（可以转换成列表）
示例代码1: 所有数字平方
def square(num):
return num ** 2
numbers = [1, 2, 3, 4, 5, 6]
result = map(square, numbers) # 将列表中的元素 依次传递给函数执行 生成一个map对象
print(list(result)) # 最后用list表示
示例代码2：使用 lambda 表达式
numbers = [1, 2, 3, 4, 5]
result = map(lambda x: x + 10, numbers)
print(list(result)) # 输出: [11, 12, 13, 14, 15]
示例代码3: 处理多个列表
a = [1, 2, 3]
b = [4, 5, 6]
result = map(lambda x, y: x + y, a, b)
print(list(result)) # 输出: [5, 7, 9]
示例代码4： 字符串转换为大写
words = ['hello', 'world', 'python']
result = map(str.upper, words)
print(list(result)) # 输出: ['HELLO', 'WORLD', 'PYTHON']
map()小结：
| 用法 | 描述 |
|---|---|
map(f, iterable) |
把函数 f 应用于每个元素 |
| 返回类型 | 是一个迭代器（需要转成 list 查看） |
| 常用于： | 批量变换数据、并行处理多个序列 |
3. Python 列表的高级用法
列表高阶用法表
| 用法 | 说明 | 示例代码 | 结果/说明 |
|---|---|---|---|
| 列表推导式 | 简洁生成新列表 | [x**2 for x in range(5)] |
[0, 1, 4, 9, 16] |
| 条件列表推导 | 带条件过滤的列表推导 | [x for x in range(10) if x%2==0] |
[0, 2, 4, 6, 8] |
| 嵌套列表推导 | 多层循环生成列表 | [(x, y) for x in [1,2] for y in [3,4]] |
[(1,3),(1,4),(2,3),(2,4)] |
使用 enumerate |
遍历同时获得索引和值 | for i, v in enumerate(lst): ... |
索引和值配对访问 |
使用 zip |
同时遍历多个列表 | for a, b in zip(lst1, lst2): ... |
对应元素同时访问 |
| 列表切片 | 截取、翻转、步长访问 | lst[::-1] 翻转列表 |
新列表，切片不改变原列表 |
filter + 列表推导 |
过滤列表元素 | list(filter(lambda x: x>5, lst)) |
返回满足条件的新列表 |
map + 列表推导 |
对列表元素做映射 | list(map(str, lst)) |
返回元素类型转换后的新列表 |
sorted + key |
自定义排序 | sorted(lst, key=lambda x: x[1]) |
根据条件排序 |
| 列表推导 + 函数调用 | 调用函数生成列表 | [func(x) for x in lst] |
灵活生成新列表 |
| 生成器表达式 | 节省内存，延迟生成 | (x**2 for x in range(10)) |
返回生成器对象 |
| 多维列表 | 列表嵌套，用于矩阵等 | matrix = [[1,2],[3,4]] |
二维列表 |
| 矩阵转置 | 利用 zip 解压操作实现 | list(zip(*matrix)) |
转置矩阵 |
| 扩展解包 | 结合 * 进行解包 |
a, *b, c = [1,2,3,4] |
a=1, b=[2,3], c=4 |
| 列表复制 | 使用切片或 list() 复制 |
lst2 = lst[:] 或 lst2 = list(lst) |
新列表，原列表不受影响 |
3.1 列表推导式
lst = [i ** 2 for i in range(10)]
print(lst) # out: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 等价于
lst = []
for i in range(10):
lst.append(i**2)
print(lst) # out: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
3.2 条件列表推导式
lst = [i for i in range(1, 10) if i%2==0]
print(lst) # out:[2, 4, 6, 8]
# 等价于
lst = []
for i in range(1, 10):
if i%2==0:
lst.append(i)
print(lst) #out: [2, 4, 6, 8]
3.3 嵌套列表推导式
lst = [(x, y) for x in [0,1,2] for y in [3, 4, 5]]
print(lst) #
# 等价于
lst = []
for x in [0, 1, 2]:
for y in [3, 4, 5]:
lst.append((x, y))
print(lst)
3. 4 枚举推导式 （推荐使用list(enumerate(列表))更高效）
lst = [(k,i) for k, i in enumerate([1 ,2, 3])]
print(lst) # out: [(0, 1), (1, 2), (2, 3)]
# 等价于
lst = []
for k, i in enumerate([1, 2, 3]):
lst.append((k,i))
print(lst)
# 或等价于 (推荐使用这个代码块)
lst = list(enumerate([1, 2, 3]))
print(lst)
3. 5 打包（zip()）推导式 (推荐使用list(zip())更高效)
lst = [(x, y) for x, y in zip([1,2,3],[4 ,5, 6])]
print(lst) #[(1, 4), (2, 5), (3, 6)]
# 等价于
lst = zip([1, 2, 3], [4, 5, 6])
print(list(lst)) # out: [(1, 4), (2, 5), (3, 6)]
3.6 切片的高级用法
lst[start:stop:step] # start为起始索引 ,stop为终止索引，step为步长 默认步长是1
# 切片是左包右开的
lst = [1, 2, 3, 4]
# 索引 0，1， 2，3
lst[1:3] # 意思是从索引为1的地方开始截取 到索引为3的地方终止截取,默认步长为1 注意！！！ 不包括索引为3的元素 用数学区间符号表示就是[1,3) 即 左包右开
| 用法 | 说明 | 示例 | 返回结果 |
|---|---|---|---|
lst[:] |
获取整个列表的浅拷贝 | [1, 2, 3][::]或[1, 2, 3][:] |
[1, 2, 3] |
lst[1:4] |
从索引1到索引3的元素 | [10, 20, 30, 40, 50][1:4] |
[20, 30, 40] |
lst[:3] |
从起始到索引2（不含3） | [1, 2, 3, 4, 5][:3] |
[1, 2, 3] |
lst[3:] |
从索引3到最后 | [1, 2, 3, 4, 5][3:] |
[4, 5] |
lst[-3:] |
从倒数第三个元素至列表末尾 | [1, 2, 3, 4, 5][-3:] |
[3, 4, 5] |
lst[::2] |
每隔一个元素取一个 | [0, 1, 2, 3, 4][::2] |
[0, 2, 4] |
lst[::-1] |
倒序列表（常用于反转） | [1, 2, 3, 4][::-1] |
[4, 3, 2, 1] |
lst[1:-1] |
去掉第一个和最后一个元素 | [10, 20, 30, 40][1:-1] |
[20, 30] |
lst[-1::-1] |
从最后一个开始倒序到开头 | [1, 2, 3, 4][-1::-1] |
[4, 3, 2, 1] |
3.6.1 利用索引浅拷贝整个列表
lst = [1, 2, 3, 4][:] # 没有起始和终止索引 默认从头拷贝到尾
# 等价于
lst = [1, 2, 3, 4][::] #没有起始和终止索引 默认从头拷贝到尾,第二个引号是截取步长默认为1(可选参数)
print(lst) # out: [1 ,2 ,3, 4]
3.6.2 有起始和终止索引的切片(切片索引规则:左包右开)
lst = [10, 20, 30, 40, 50][1:4] # 截取索引为1到4(不含4)的列表元素 默认步长为1
print(lst) # out: 20, 30, 40
3.6.3 没有起始索引, 有终止索引
lst = [1, 2, 3, 4, 5][:3] # 默认从列表索引为0的地方开始截取 到3(但不包括3)的地方停止，默认步长为1
print(lst) # out: [1, 2, 3]
3.6.4 有起始索引，没有终止索引
lst = [1, 2, 3, 4, 5][3:] # 从索引位置为3的位置开始截取元素至列表最后一个元素(包括最后一个元素)。默认步长为1
print(lst) # out: [4, 5]
3.6.5 起始索引为负数，没有终止索引
lst =[1, 2, 3, 4, 5][-3:] # 从列表倒数第三个元素开始截取到列表末尾，步长为1
print(lst) # out: [3, 4, 5]
3.6.6 切片步长不为1时
lst = [0, 1, 2, 3, 4][::2] # 从索引 0 开始，每隔 2 个索引取一个元素（步长为 2）
print(lst) # 输出: [0, 2, 4]
3.6.7 倒序列表
方法一：
lst = [1, 2, 3, 4][::-1]
# 步长为 -1，表示从右向左取元素（倒序）
# 没有写起始索引和终止索引，默认从最后一个元素开始，到第一个元素结束（不包含终止索引的下一位）
# 实际效果是将整个列表反转，得到 [4, 3, 2, 1]
print(lst) # 输出: [4, 3, 2, 1]
方法二:
lst = [1, 2, 3, 4][-1::-1]
# 从索引 -1（即 4）开始，向左每次移动 1 个位置（步长为 -1）
# 直到无法再向左（超出索引）为止
# 实现效果是将整个列表倒序
print(lst) # 输出: [4, 3, 2, 1]
3.6.8 起始索引是正数 终止索引是负数
lst = [10, 20, 30, 40][1:-1]
# 列表为 [10, 20, 30, 40]
# 从索引 1 开始（包括 20）
# 到索引 -1 结束（不包括索引 -1 对应的元素，即 40）
# -1 表示倒数第一个元素的索引
# 所以切片结果是 [20, 30]
print(lst) # 输出: [20, 30]
3.7 筛选 + 列表推导 （for循环 + if）
numbers = [1, 2, 3, 4, 5, 6]
even = [x for x in numbers if x % 2 == 0] # 筛选出余数为0的元素
print(even) # 输出: [2, 4, 6]
3.8 映射 + 列表推导 （func + for循环）
numbers = [1, 2, 3, 4, 5]
squares = [x ** 2 for x in numbers]
print(squares) # 输出: [1, 4, 9, 16, 25]
3.9 自定义排序 for 循环 + sorted()
回顾 : sorted():
| 参数名 | 类型 | 说明 |
|---|---|---|
iterable |
可迭代对象 | 必填。任何可迭代对象，如列表、元组、字符串、字典（排序键）等 |
key |
函数或None |
选填。指定排序的“依据函数”，会对 iterable 中的每个元素应用该函数，按返回值排序 |
reverse |
布尔值 | 选填。默认 False，表示升序。设为 True 表示降序 |
key参数用法:
| 用法 | 示例 |
|---|---|
| 按长度排序 | key=len |
| 自定义函数 | key=lambda x: x[1] |
| 忽略大小写排序字符串 | key=str.lower |
| 按多个字段排序（使用元组） | key=lambda x: (x[1], x[0]) |
示例一：
numbers = [3, 1, 4, 2]
squares = [x**2 for x in sorted(numbers)] # 从小到大排序 (升序)
print(squares) # 输出: [1, 4, 9, 16]
示例二：
numbers = [3, 1, 4, 2]
squares = [x**2 for x in sorted(numbers, reverse=True)] # 从大到小排序 （降序）
print(squares) # 输出: [16, 9, 4, 1]
示例三
lst = [('a',3),('b',1),('c',5),('d',0)]
lst2 = [(x, y) for x, y in sorted(lst, key=lambda item:item[1])] # 按照元组的第二项，从小到大排序 表达式中会依次向lambda表达式传递列表中的元素(即元组)
print(lst2) # out:[('d', 0), ('b', 1), ('a', 3), ('c', 5)]
3.10 列表推导 + 函数调用 func() + for循环
示例1：
def cube(x): # 求立方
return x**3
lst = [cube(i) for i in range(10)]
print(lst) # 输出 [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
示例2：
lst = [i**3 for i in range(10)]
print(lst) # 输出 [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
3.11 多维列表
matrix = [[1,2],[3,4]] # 生成一个二维列表
print(matrix) # [[1, 2], [3, 4]]
3.12 矩阵转置
matrix = [[1,2],[3,4]]
lst = list(zip(*matrix))
print(lst) # [(1, 3), (2, 4)]
原理解析：
*matrix 表示把 matrix 中的两个子列表“解包”出来，传递给 zip()：等效于：
zip([1, 2], [3, 4])
zip() 会将对应位置的元素配对：(1, 3)(2, 4)所以 zip(*matrix) 的作用是 转置二维矩阵
| 原矩阵 | 转置后 |
|---|---|
| [1, 2] | (1, 3) |
| [3, 4] | (2, 4) |
3.13 列表解包
a, *b, c = [1,2,3,4]
print("a:",a)
print('b:',b)
print('c:',c)
"""
a: 1
b: [2, 3]
c: 4
"""
星号（*）解包赋值规律表
| 解包形式 | 赋值规则 | 示例 | 结果 |
|---|---|---|---|
a, *b = seq |
a 取第一个，b 取剩下所有 |
a, *b = [1, 2, 3] |
a=1, b=[2, 3] |
*a, b = seq |
b 取最后一个，a 取前面所有 |
*a, b = [1, 2, 3] |
a=[1, 2], b=3 |
a, *b, c = seq |
a 取第一个，c 取最后一个，b 取中间 |
a, *b, c = [1, 2, 3, 4] |
a=1, b=[2, 3], c=4 |
a, b, *c = seq |
a,b 前两个，c 剩余 |
a, b, *c = [1, 2, 3, 4] |
a=1, b=2, c=[3, 4] |
*a, b, c = seq |
b,c 最后两个，a 剩余 |
*a, b, c = [1, 2, 3, 4] |
a=[1, 2], b=3, c=4 |
a, *b, c, d = seq |
a 第一个，c,d 最后两个，b 中间 |
a, *b, c, d = [1, 2, 3, 4, 5] |
a=1, b=[2, 3], c=4, d=5 |
注意事项
SyntaxError）。使用场景
| 场景 | 示例 |
|---|---|
| 忽略多个值 | a, *_, b = [1, 2, 3, 4, 5] |
| 分离头部/尾部 | head, *body = seq 或 *body, tail = seq |
| 拆包+函数传参 | func(*args) |
补充：
-
拆分列表的头部和尾部
只解包第一个元素
names = ["Tom", "Jerry", "Spike", "Tyke"] first, *rest = names # 解包第一个元素给first, 剩下的给rest print(first) # Tom print(rest) # ['Jerry', 'Spike', 'Tyke']只解包最后一个元素
names = ["Tom", "Jerry", "Spike", "Tyke"] *body, last = names # 解包最后一个元素 print(body) # ['Tom', 'Jerry', 'Spike'] print(last) # Tyke -
忽略中间多个值
data = [100, 200, 300, 400, 500] start, *_, end = data print(start) # 100 print(end) # 500 -
函数参数解包
- 调用函数时解包
def add(a, b, c): return a + b + c args = [1, 2, 3] print(add(*args)) # 6解析：
一句话解释
*args在函数调用中，
*args是一种 “解包操作”，它会把一个可迭代对象（如列表、元组）打散成一个个单独的参数，传入函数。详细解释
args = [1, 2, 3]这是一个包含 3 个整数的列表。
*args表示“解包 argsadd(*args)相当于
add(1, 2, 3)# *args` 的作用是把列表 `[1, 2, 3]` 中的元素依次取出，分别传给 `a`, `b`, `c- 定义函数时解包
def add(*args): # 接受任意数量的位置参数 count = 0 for i in args: # args此时被封装成一个元组 count += i return count print(add(5,4,3,2,1)) # out 15在函数定义中，
*args表示可以接收任意多个位置参数，并将它们封装成一个元组（tuple）。print(args) # 输出：(5, 4, 3, 2, 1) print(type(args)) # <class 'tuple'>总结:
形式 含义 *args在函数 调用时使用：将可迭代对象解包成多个位置参数 *args在函数 定义时使用：表示可以接受多个位置参数，放进一个元组中（这是另一种情况）
作者：通辽汗国尚书令
