Python 列表

小田测测看

发布于 2026-06-17 17:24:38

1070

列表是 Python 中最常用的序列类型之一，因其灵活的特性在实际开发中被广泛使用。本文系统总结列表的核心知识，并针对面试中高频出现的考点进行解析。

一、列表的基本特性

1. 定义

列表通过方括号 [] 定义，元素之间用逗号分隔，支持存储不同类型的数据：

# 空列表
empty_list = []
empty_list = list()  # 另一种创建方式

# 普通列表
num_list = [1, 2, 3, 4]
mix_list = [1, "hello", True, 3.14]  # 元素类型可混合

2. 特性

• 可变性：列表创建后可修改元素（与字符串的不可变性形成对比）

my_list = [1, 2, 3]
my_list[0] = 100  # 合法操作，列表支持元素修改

• 有序性：元素按插入顺序排列，支持索引访问（Python 3.7+ 后字典也保证有序，但列表的有序性是其原生特性）
• 动态扩容：无需预先指定长度，可动态添加 / 删除元素
• 内存特征：列表存储的是元素的引用（地址），而非元素本身，因此修改嵌套对象会影响列表中的对应元素：

sub_list = [1, 2]
main_list = [sub_list, 3, 4]
sub_list.append(5)
print(main_list)  # 输出：[[1, 2, 5], 3, 4]（子列表修改影响主列表）

二、基础操作

1. 索引与切片

my_list = ["a", "b", "c", "d"]
print(my_list[1])   # 正向索引：b
print(my_list[-2])  # 反向索引：c

• 切片操作：语法 list[start:end:step]，返回新列表（左闭右开区间）

my_list = [0, 1, 2, 3, 4, 5]
print(my_list[1:4])    # [1, 2, 3]（从索引1到3）
print(my_list[:3])     # [0, 1, 2]（从头开始到索引2）
print(my_list[3:])     # [3, 4, 5]（从索引3到末尾）
print(my_list[::2])    # [0, 2, 4]（步长为2，间隔取元素）
print(my_list[::-1])   # [5, 4, 3, 2, 1, 0]（反转列表）

面试考点：切片操作会创建新列表，而非修改原列表。例如 my_list[1:3] = [10, 20] 是修改原列表，而 new_list = my_list[1:3] 是生成新列表。

2. 常用操作符

• 拼接：+ 用于合并列表（返回新列表，原列表不变）

list1 = [1, 2]
list2 = [3, 4]
print(list1 + list2)  # [1, 2, 3, 4]

• 重复：* 用于重复列表元素

print([0] * 3)  # [0, 0, 0]
print([1, 2] * 2)  # [1, 2, 1, 2]

• 成员判断：in / not in 检查元素是否在列表中

print(2 in [1, 2, 3])  # True
print("a" not in [1, 2, 3])  # True

三、一些方法

方法	功能描述	示例
append(x)	在列表末尾添加元素 x	[1,2].append(3) → [1,2,3]
extend(iter)	用可迭代对象的元素扩展列表	[1,2].extend([3,4]) → [1,2,3,4]
insert(i, x)	在索引 i 处插入元素 x	[1,3].insert(1,2) → [1,2,3]
remove(x)	删除第一个值为 x 的元素（无返回值）	[1,2,2].remove(2) → [1,2]
pop(i)	删除并返回索引 i 处的元素（默认最后一个）	[1,2,3].pop() → 3（列表变为 [1,2]）
index(x)	返回第一个值为 x 的元素索引	[1,2,3].index(2) → 1
count(x)	统计元素 x 在列表中出现的次数	[1,2,2,3].count(2) → 2
sort()	原地排序（默认升序，无返回值）	[3,1,2].sort() → [1,2,3]
reverse()	原地反转列表（无返回值）	[1,2,3].reverse() → [3,2,1]
copy()	返回列表的浅拷贝	a = [1,2]; b = a.copy() → b 是新列表

面试易错点：

• append vs extend：append 会将整个对象作为单个元素添加，extend 会拆分可迭代对象：

a = [1, 2]
a.append([3, 4])  # 结果：[1, 2, [3, 4]]（添加列表作为元素）
a.extend([3, 4])  # 结果：[1, 2, 3, 4]（拆分列表添加元素）

• sort vs sorted：list.sort() 是原地排序（修改原列表，返回 None），sorted(list) 是返回新列表（原列表不变）：

a = [3, 1, 2]
b = sorted(a)  # a 仍为 [3,1,2]，b 为 [1,2,3]
a.sort()       # a 变为 [1,2,3]，返回 None

1. 列表推导式--很常用

# 基本格式：[表达式 for 变量 in 可迭代对象 if 条件]
squares = [x**2 for x in range(10)]  # [0, 1, 4, ..., 81]

# 带条件筛选
even_numbers = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

# 嵌套循环（等价于二维列表扁平化）
matrix = [[1, 2], [3, 4], [5, 6]]
flatten = [num for row in matrix for num in row]  # [1, 2, 3, 4, 5, 6]

来个小面试题：实现矩阵转置（如 [[1,2],[3,4]] → [[1,3],[2,4]]）

matrix = [[1, 2], [3, 4], [5, 6]]
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]

2. 深浅拷贝

• 浅拷贝：只复制列表本身，嵌套对象仍共享引用

a = [1, [2, 3]]
b = a.copy()  # 或 b = a[:]
b[0] = 100    # 修改外层元素，不影响 a
b[1].append(4)  # 修改嵌套列表，a 也会变化
print(a)  # [1, [2, 3, 4]]（嵌套对象被修改）

• 深拷贝：需使用 copy 模块，完全复制所有层级的对象

import copy
a = [1, [2, 3]]
b = copy.deepcopy(a)
b[1].append(4)
print(a)  # [1, [2, 3]]（a 不受影响）

面试题：如何区分浅拷贝和深拷贝？

3. 列表与其他数据结构的转换

• 列表 → 元组：tuple(list)（元组不可变，适合作为字典键）
• 列表 → 集合：set(list)（去重，无序）
• 字符串 → 列表：list(str) 或 str.split()

4. 如何在列表中查找某个元素的所有位置？

def find_all_indices(lst, target):
    return [i for i, x in enumerate(lst) if x == target]

# 示例：find_all_indices([1,2,2,3], 2) → [1, 2]

5. 如何实现两个列表的交集、并集和差集？

a = [1, 2, 3, 4]
b = [3, 4, 5, 6]

# 交集（共有的元素）
intersection = list(set(a) & set(b))  # [3,4]

# 并集（所有元素，去重）
union = list(set(a) | set(b))  # [1,2,3,4,5,6]

# 差集（a有b没有的元素）
difference = list(set(a) - set(b))  # [1,2]