python list函数汇总

⚡ 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)  # []

〔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〕高频答疑

Q1:为什么sort()返回None?
A:这是设计哲学——原地修改方法返回None,避免误以为返回新列表。若需新排序列表,应使用sorted()。
Q2:列表相加是否高效?
A:[1,2] + [3,4]会创建新列表,频繁使用会导致O(n²)时间。更高效方式是预分配列表或用extend()。
Q3:如何删除所有匹配元素?
A:remove()只删首个。可循环删除或用推导式过滤:
s = [x for x in s if x != target]
Q4:切片赋值时右侧为空列表会怎样?
A:lst[start:stop] = []相当于删除该切片范围的元素(等效于del lst[start:stop])。