⚡ python list函数汇总总览
Python list(列表)是Python中最基础、最常用的数据结构之一,属于可变序列类型,支持动态增删元素、原地修改内容。相较于tuple(元组)的不可变性,list在实际开发中拥有极高的灵活性与实用性,广泛应用于数据处理、算法实现、自动化脚本等场景。
从底层实现看,Python的list本质是动态数组(Array List),即底层以连续内存块存储元素引用,支持O(1)时间复杂度的随机访问,但中间插入/删除操作平均为O(n)时间复杂度。当容量不足时,会自动扩容至原容量约1.125倍+常数,确保摊还插入效率接近O(1)。
截至Python 3.12,list对象共提供以下11个核心方法(含原地修改与返回新对象两类),另加切片、推导式等语言级特性,构成完整操作体系:
- append():末尾添加单个元素
- extend():用可迭代对象扩展列表
- insert():指定位置插入元素
- remove():删除首个匹配值
- pop():移除并返回指定索引元素(默认末尾)
- clear():清空列表所有元素
- count():统计某值出现次数
- index():查找某值首次出现索引
- sort():原地排序(支持key与reverse)
- reverse():原地反转列表
- copy():浅拷贝(等效于
lst[:])
除上述方法外,Python还提供丰富的语法糖与内置函数协同操作list,如len()、min()、max()、sum()、sorted()、enumerate()、zip()等,进一步提升开发效率。
⚙️ 创建与初始化
〔1〕字面量创建
最直接方式为使用方括号[]:
# 创建空列表
empty = []
# 创建含整数的列表
nums = [1, 2, 3, 4]
# 创建混合类型列表(Python允许)
mixed = [1, "hello", 3.14, True, None]
# 嵌套列表(二维列表)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
⚠️ 注意:嵌套列表中子列表为独立对象,修改一个子列表不影响其他:
a = [[1, 2]] * 3 # ❌ 错误用法:三个子列表指向同一对象
a[0][0] = 99
print(a) # [[99, 2], [99, 2], [99, 2]]
b = [[1, 2] for _ in range(3)] # ✅ 正确:每个子列表独立
b[0][0] = 99
print(b) # [[99, 2], [1, 2], [1, 2]]
〔2〕内置函数list()转换
list()可将任意可迭代对象(字符串、元组、集合、range、生成器等)转换为列表:
list("abc") # ['a', 'b', 'c']
list((1, 2, 3)) # [1, 2, 3]
list({1, 2, 2}) # [1, 2](集合自动去重)
list(range(3,8,2)) # [3, 5, 7]
list(map(str, [1,2,3])) # ['1', '2', '3']
〔3〕列表推导式
高效创建新列表的语法结构,形式为[表达式 for 变量 in 可迭代对象 if 条件]:
[x**2 for x in range(5)] # [0, 1, 4, 9, 16]
[x for x in range(20) if x % 3 == 0] # [0, 3, 6, 9, 12, 15, 18]
[(x, y) for x in [1,2] for y in ['a','b']] # [(1,'a'),(1,'b'),(2,'a'),(2,'b')]
推导式本质是循环语法糖,性能优于等效for循环+append,且更简洁易读。
〔4〕元素访问与索引
〔1〕正向索引(0-based)
列表索引从0开始递增,支持负索引(倒序访问):
s = ["a", "b", "c", "d", "e"]
s[0] # 'a'
s[-1] # 'e'
s[-2] # 'd'
〔2〕切片操作(slice)
语法:list[start:stop:step],返回新列表(浅拷贝),原列表不变:
start:起始索引(默认0)stop:结束索引(不包含,默认len(lst))step:步长(默认1,可负)
s[1:4] # ['b', 'c', 'd']
s[:3] # ['a', 'b', 'c']
s[2:] # ['c', 'd', 'e']
s[::2] # ['a', 'c', 'e']
s[::-1] # ['e', 'd', 'c', 'b', 'a']
s[1:4:2] # ['b', 'd']
切片越界不会报错(自动截断),但索引越界会抛IndexError:
s[10] # IndexError: list index out of range
s[10:12] # [](空列表)
〔3〕嵌套列表访问
使用连续索引访问多维结构:
m = [[1,2,3],[4,5,6],[7,8,9]]
m[1][2] # 6(第2行第3列)
m[0][1] = 99
print(m) # [[1,99,3], [4,5,6], [7,8,9]]
〔5〕原地修改操作
〔1〕赋值单个元素
s = ["a", "b", "c"]
s[1] = "B"
print(s) # ['a', 'B', 'c']
〔2〕切片赋值(替换/插入/删除)
切片赋值可实现灵活的原地修改,注意右侧必须为可迭代对象:
s = [1, 2, 3, 4, 5]
s[1:3] = [20, 30] # 替换 → [1, 20, 30, 4, 5]
s[1:3] = [99] # 替换为单元素 → [1, 99, 4, 5]
s[1:1] = [7, 8] # 插入 → [1, 7, 8, 99, 4, 5]
s[1:4] = [] # 删除 → [1, 4, 5]
s[:] = [10, 20] # 清空+重填 → [10, 20]
⚠️ 注意:切片赋值时右侧必须是可迭代对象,单值需包装为列表:
s[0] = 100 # ✅ 单元素赋值
s[0:1] = 100 # ❌ TypeError: can only assign an iterable
s[0:1] = [100] # ✅ 正确:包装为列表
〔3〕原地反转
s = [1, 2, 3, 4]
s.reverse()
print(s) # [4, 3, 2, 1]
与切片s[::-1]区别:前者原地修改(O(n)时间,O(1)空间),后者生成新列表(O(n)时间,O(n)空间)。
〔6〕添加元素
〔1〕append()
在末尾添加单个元素(O(1)摊还时间):
s = [1, 2]
s.append(3)
print(s) # [1, 2, 3]
s.append([4,5])
print(s) # [1, 2, 3, [4, 5]](嵌套子列表)
〔2〕extend()
用可迭代对象的元素扩展列表(原地修改):
s = [1, 2]
s.extend([3, 4])
print(s) # [1, 2, 3, 4]
s.extend("ab")
print(s) # [1, 2, 3, 4, 'a', 'b'](字符串被拆分为字符)
⚠️ 与append()关键区别:
append(x):添加整个对象x(无论类型)extend(iterable):添加iterable中的每个元素
〔3〕insert()
在指定索引前插入元素(O(n)时间):
s = [1, 3, 4]
s.insert(1, 2) # 在索引1前插入 → [1, 2, 3, 4]
s.insert(10, 99) # 索引超界 → 插入末尾 → [1, 2, 3, 4, 99]
s.insert(-1, 88) # 负索引 → 在倒数第1前插入 → [1, 2, 3, 4, 88, 99]
〔7〕删除元素
〔1〕remove()
删除首个匹配值(O(n)时间),值不存在则抛ValueError:
s = ["a", "b", "c", "b"]
s.remove("b")
print(s) # ['a', 'c', 'b']
s.remove("x") # ValueError: list.remove(x): x not in list
〔2〕pop()
移除并返回指定索引元素(默认末尾),索引越界抛IndexError:
s = [10, 20, 30]
last = s.pop() # 30,s变为[10, 20]
first = s.pop(0) # 10,s变为[20]
s.pop(10) # IndexError: pop index out of range
〔3〕del语句
支持删除单个元素、切片或整个列表:
s = [1, 2, 3, 4, 5]
del s[1] # → [1, 3, 4, 5]
del s[1:3] # → [1, 5]
del s[:] # 清空 → []
del s # 删除列表对象(后续访问报NameError)
〔4〕clear()
清空所有元素(等效于del lst[:]):
s = [1, 2, 3]
s.clear()
print(s) # []
〔8〕搜索与统计
〔1〕count()
统计某值在列表中出现次数(O(n)时间):
[1, 2, 2, 3, 2].count(2) # 3
["a", "b", "a", "c"].count("x") # 0
〔2〕index()
查找某值首次出现索引(O(n)时间),可指定搜索范围:
s = ["a", "b", "c", "b", "d"]
s.index("b") # 1
s.index("b", 2) # 3(从索引2起查找)
s.index("b", 1, 4) # 1(左闭右开区间[1,4))
s.index("x") # ValueError: 'x' is not in list
〔3〕成员测试
使用in或not in判断元素存在性(O(n)时间):
2 in [1,2,3] # True
"z" not in ["a","b"] # True
〔9〕排序操作
〔1〕原地排序 sort()
语法:list.sort(key=None, reverse=False),返回None(原地修改):
s = [3, 1, 4, 1, 5]
s.sort() # [1, 1, 3, 4, 5]
s.sort(reverse=True) # [5, 4, 3, 1, 1]
# 自定义排序键:按字符串长度
words = ["apple", "pie", "banana"]
words.sort(key=len) # ['pie', 'apple', 'banana']
# 复杂键:先按长度,再按字典序
words.sort(key=lambda x: (len(x), x)) # ['pie', 'apple', 'banana']
〔2〕内置函数 sorted()
返回新排序列表(不修改原列表),支持任意可迭代对象:
s = [3, 1, 4, 1, 5]
sorted(s) # [1, 1, 3, 4, 5]
s # [3, 1, 4, 1, 5](原列表未变)
sorted("cba") # ['a', 'b', 'c']
sorted([(2, 'b'), (1, 'a')], key=lambda x: x[0]) # [(1,'a'), (2,'b')]
〔3〕稳定排序说明
Python的sort()与sorted()均采用Timsort算法,保证稳定排序(相等元素相对顺序不变),适用于需要保留原始顺序的场景。
〔10〕拷贝操作
〔1〕浅拷贝方法
list.copy():Python 3.3+新增方法lst[:]`:切片拷贝(通用)list(lst):构造函数拷贝
a = [1, [2, 3]]
b = a.copy()
c = a[:]
a[0] = 99
print(b) # [1, [2, 3]](顶层修改不影响拷贝)
print(c) # [1, [2, 3]]
a[1][0] = 88
print(b) # [1, [88, 3]](嵌套对象仍共享)
print(c) # [1, [88, 3]]
〔2〕深拷贝(需导入模块)
当需要完全独立的副本时,需使用copy.deepcopy():
import copy
a = [1, [2, 3]]
d = copy.deepcopy(a)
a[1][0] = 88
print(d) # [1, [2, 3]](深拷贝完全独立)
〔11〕高级技巧与最佳实践
〔1〕列表推导式变体
支持条件表达式与嵌套推导式:
# 条件表达式(类似三元运算)
[x if x % 2 == 0 else -x for x in range(5)]
# [0, -1, 2, -3, 4]
# 等效for循环写法(更复杂逻辑时可读性更高)
result = []
for x in range(5):
result.append(x if x % 2 == 0 else -x)
〔2〕同时遍历索引与值
使用enumerate()避免手动计数:
s = ["a", "b", "c"]
for i, ch in enumerate(s):
print(f"{i}: {ch}")
# 0: a
# 1: b
# 2: c
# 指定起始索引
for i, ch in enumerate(s, start=1):
print(f"{i}: {ch}")
# 1: a
# 2: b
# 3: c
〔3〕并行遍历多个列表
使用zip()组合多个序列:
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
print(f"{name}: {score}")
# Alice: 85
# Bob: 92
# Charlie: 78
# 转为列表(zip对象可迭代一次)
list(zip(names, scores)) # [('Alice',85), ('Bob',92), ('Charlie',78)]
〔4〕列表转字符串
用str.join()连接字符串列表:
words = ["Python", "list", "tricks"]
" ".join(words) # "Python list tricks"
"-".join(map(str, [1,2,3])) # "1-2-3"
〔5〕列表去重(保持顺序)
传统方法(字典键去重):从Python 3.7起,字典保持插入顺序:
lst = [1, 2, 2, 3, 1, 4]
list(dict.fromkeys(lst)) # [1, 2, 3, 4]
或使用集合记录已见元素:
seen = set()
result = []
for x in lst:
if x not in seen:
seen.add(x)
result.append(x)
〔13〕高频答疑
sort()返回None?None,避免误以为返回新列表。若需新排序列表,应使用sorted()。[1,2] + [3,4]会创建新列表,频繁使用会导致O(n²)时间。更高效方式是预分配列表或用extend()。remove()只删首个。可循环删除或用推导式过滤:s = [x for x in s if x != target]lst[start:stop] = []相当于删除该切片范围的元素(等效于del lst[start:stop])。