【Python 列表操作：定义、索引、切片、遍历常用方法，一篇搞定！】

Python 列表操作：定义、索引、切片、遍历与 18 个常用方法，一篇搞定！

摘要

本文从零开始系统讲解 Python 列表的全部核心操作。从列表的定义与创建讲起，深入索引正负取值规则和切片步长技巧，覆盖三种遍历方式和嵌套列表处理，最后用表格速览 append、extend、sort、pop、copy 等 18 个常用方法及其时间复杂度。文末附有速查表和常见坑点总结，适合 Python 初学者和需要系统性复习列表操作的开发者。

Python 列表是使用频率最高的内置数据结构。掌握它的 18 个常用方法，等于拿下 80% 的数据处理场景。

列表（list）是 Python 中最灵活、最常用的内置数据结构。它是有序的、可变的、可包含任意类型元素的容器。无论你是写脚本、做数据分析还是 Web 开发，列表操作几乎出现在每一段代码中。

本文将带你从定义开始，逐步深入索引、切片、遍历三大核心操作，最后用表格快速查阅 18 个常用方法。

一、基础认识

1.1 什么是列表

列表是 Python 内置的有序、可变、可重复的序列类型，用方括号 [] 表示，元素之间用逗号分隔。

# 空列表
empty = []
print(empty) # []

# 整数列表
nums = [1, 2, 3, 4, 5]
print(nums) # [1, 2, 3, 4, 5]

# 混合类型列表
mixed = [1, "hello", 3.14, True, [1, 2]]
print(mixed) # [1, 'hello', 3.14, True, [1, 2]]

列表中的元素可以是任意 Python 对象，包括另一个列表（形成嵌套列表）。与字符串和元组不同，列表创建后可以任意增、删、改。

1.2 五种创建方式

# 1. 字面量创建
a = [1, 2, 3]

# 2. list() 构造器从可迭代对象创建
b = list("abc") # ['a', 'b', 'c']
c = list(range(5)) # [0, 1, 2, 3, 4]
d = list((1, 2, 3)) # [1, 2, 3] 从元组转换

# 3. 列表推导式
e = [x ** 2 for x in range(5)] # [0, 1, 4, 9, 16]

# 4. 乘法创建重复元素列表
f = [0] * 5 # [0, 0, 0, 0, 0]

# 5. split() 从字符串创建
g = "apple,banana,cherry".split(",") # ['apple', 'banana', 'cherry']

注意：[[]] * 3 会创建三个指向同一子列表的引用，修改一个会影响全部。需要独立子列表时用列表推导式：[[] for _ in range(3)]。

二、核心操作

2.1 索引 —— 精准定位元素

Python 列表支持正向索引（从左到右，从 0 开始）和反向索引（从右到左，从 -1 开始）。

nums = [10, 20, 30, 40, 50]

# 正向索引：0, 1, 2, 3, 4
print(nums[0]) # 10 第一个元素
print(nums[2]) # 30 第三个元素
print(nums[4]) # 50 最后一个元素

# 反向索引：-1, -2, -3, -4, -5
print(nums[–1]) # 50 最后一个元素
print(nums[–2]) # 40 倒数第二个
print(nums[–5]) # 10 倒数第五个（即第一个）

# 索引越界会报错
# print(nums[5]) # IndexError: list index out of range
# print(nums[-6]) # IndexError: list index out of range

索引规则速记：

2.2 切片 —— 批量截取子列表

切片语法：list[start:stop:step]，三个参数均可省略。

• start：起始索引（包含），默认 0
• stop：结束索引（不包含），默认到末尾
• step：步长，默认 1；负数表示反向取

nums = [10, 20, 30, 40, 50, 60, 70, 80]

# 基础切片
print(nums[1:5]) # [20, 30, 40, 50] 索引 1 到 4，不含 5
print(nums[:4]) # [10, 20, 30, 40] start 省略，从 0 开始
print(nums[3:]) # [40, 50, 60, 70, 80] stop 省略，到末尾
print(nums[:]) # [10, 20, …, 80] 完整复制（浅拷贝）

# 带步长
print(nums[::2]) # [10, 30, 50, 70] 每隔一个取
print(nums[1:7:2]) # [20, 40, 60] 从索引 1 到 6，步长 2

# 反向切片
print(nums[::–1]) # [80, 70, 60, 50, 40, 30, 20, 10] 反转列表
print(nums[5:1:–1]) # [60, 50, 40, 30] 从索引 5 递减到索引 2
print(nums[–1:–5:–1]) # [80, 70, 60, 50] 反向取最后 4 个

# 切片的容错性非常好——越界不会报错
print(nums[2:100]) # [30, 40, 50, 60, 70, 80] 自动截断

切片口诀：[起始:结束:步长]，左闭右开不含尾，步长默认 1，负数反向走，省略即到头。

2.3 遍历 —— 三种常用方式

fruits = ["apple", "banana", "cherry"]

# 方式 1：直接遍历元素 —— 最简洁
for fruit in fruits:
print(fruit)
# 输出：
# apple
# banana
# cherry

# 方式 2：enumerate() —— 同时要索引和值
for i, fruit in enumerate(fruits):
print(f"{i}: {fruit}")
# 输出：
# 0: apple
# 1: banana
# 2: cherry

# enumerate 可指定起始编号
for i, fruit in enumerate(fruits, start=1):
print(f"{i}. {fruit}")
# 输出：
# 1. apple
# 2. banana
# 3. cherry

# 方式 3：range(len()) —— 按索引遍历
for i in range(len(fruits)):
print(f"fruits[{i}] = {fruits[i]}")
# 输出：
# fruits[0] = apple
# fruits[1] = banana
# fruits[2] = cherry

2.4 嵌套列表的遍历

matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

# 二维遍历
for row in matrix:
for item in row:
print(item, end=" ")
# 输出：1 2 3 4 5 6 7 8 9

# 带索引的二维遍历
for i, row in enumerate(matrix):
for j, val in enumerate(row):
print(f"matrix[{i}][{j}] = {val}")
# 输出：
# matrix[0][0] = 1
# matrix[0][1] = 2
# …

三、18 个常用方法大全

3.1 增加元素

nums = [1, 2, 3]

# 1. append(x) —— 尾部追加单个元素（最常用）
nums.append(4)
print(nums) # [1, 2, 3, 4]

# 2. extend(iterable) —— 尾部追加多个元素
nums.extend([5, 6])
print(nums) # [1, 2, 3, 4, 5, 6]

# 3. insert(i, x) —— 在指定索引处插入
nums.insert(0, 0) # 在开头插入
print(nums) # [0, 1, 2, 3, 4, 5, 6]
nums.insert(3, 99) # 在索引 3 处插入
print(nums) # [0, 1, 2, 99, 3, 4, 5, 6]

3.2 删除元素

nums = [10, 20, 30, 20, 40]

# 4. remove(x) —— 移除第一个匹配值
nums.remove(20)
print(nums) # [10, 30, 20, 40] 只删除了第一个 20

# 5. pop([i]) —— 移除并返回指定索引的元素（默认最后）
last = nums.pop()
print(last) # 40
print(nums) # [10, 30, 20]
second = nums.pop(1)
print(second) # 30
print(nums) # [10, 20]

# 6. clear() —— 清空所有元素
nums.clear()
print(nums) # []

# 7. del 语句 —— 按索引或切片删除（不是方法，但常用）
lst = [1, 2, 3, 4, 5]
del lst[1] # 删除索引 1
print(lst) # [1, 3, 4, 5]
del lst[1:3] # 删除切片
print(lst) # [1, 5]

3.3 查找与统计

nums = [10, 20, 30, 20, 40]

# 8. index(x[, start[, end]]) —— 返回第一个匹配值的索引
print(nums.index(20)) # 1 第一个 20 在索引 1
print(nums.index(20, 2)) # 3 从索引 2 开始找，在索引 3 找到
# nums.index(99) # ValueError: 99 is not in list

# 9. count(x) —— 统计元素出现次数
print(nums.count(20)) # 2
print(nums.count(99)) # 0

# 10. len(list) —— 获取列表长度（内置函数，不是方法）
print(len(nums)) # 5

# 11. x in list / x not in —— 成员检查（运算符）
print(30 in nums) # True
print(99 not in nums) # True

3.4 排序与反转

# 12. sort(key=None, reverse=False) —— 原地排序
nums = [3, 1, 4, 1, 5, 9, 2]
nums.sort()
print(nums) # [1, 1, 2, 3, 4, 5, 9]

nums.sort(reverse=True)
print(nums) # [9, 5, 4, 3, 2, 1, 1]

# 自定义排序 key
words = ["apple", "banana", "kiwi", "cherry"]
words.sort(key=len) # 按长度排序
print(words) # ['kiwi', 'apple', 'banana', 'cherry']

words.sort(key=lambda s: s[–1]) # 按最后一个字符排序
print(words) # ['banana', 'apple', 'kiwi', 'cherry']

# 13. reverse() —— 原地反转
nums = [1, 2, 3, 4]
nums.reverse()
print(nums) # [4, 3, 2, 1]

# 14. sorted(list) —— 返回新排序列表，原列表不变
nums = [3, 1, 2]
new = sorted(nums)
print(new) # [1, 2, 3]
print(nums) # [3, 1, 2] 原列表不变

3.5 复制与转换

# 15. copy() —— 浅拷贝
nums = [1, 2, [3, 4]]
shallow = nums.copy()
shallow[0] = 99
shallow[2][0] = 88 # 嵌套列表的修改会影响原列表
print(nums) # [1, 2, [88, 4]] 内层被影响！
print(shallow) # [99, 2, [88, 4]]

# 切片也是一种浅拷贝方式
nums2 = nums[:]

# 深拷贝需要 import copy 模块
import copy
nums = [1, 2, [3, 4]]
deep = copy.deepcopy(nums)
deep[2][0] = 88
print(nums) # [1, 2, [3, 4]] 原列表完全不受影响

# 16. + 拼接 —— 生成新列表
a = [1, 2]
b = [3, 4]
c = a + b
print(c) # [1, 2, 3, 4]
print(a) # [1, 2] 不变

# 17. * 重复 —— 生成新列表
print([0] * 3) # [0, 0, 0]
print([1, 2] * 2) # [1, 2, 1, 2]

# 18. join() 与 split() —— 列表与字符串互转
words = ["Hello", "World", "Python"]
sentence = " ".join(words)
print(sentence) # Hello World Python

chars = list("abc") # 字符串转字符列表
print(chars) # ['a', 'b', 'c']

3.6 列表推导式

# 基础推导式
squares = [x**2 for x in range(10) if x % 2 == 0]
print(squares) # [0, 4, 16, 36, 64]

# 嵌套推导式：展平二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
print(flat) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# if-else 推导式
labels = ["even" if x % 2 == 0 else "odd" for x in range(5)]
print(labels) # ['even', 'odd', 'even', 'odd', 'even']

四、总结与速查

4.1 全部方法速查表

4.2 常见坑点

4.3 一句话总结

列表是 Python 的万能容器：用索引和切片定位位置，用 append/extend/pop/remove 增删内容，用 sort/reverse/copy 整理数据，用列表推导式一行写完循环逻辑。

你在列表操作中踩过哪些坑？或者还有哪些好用但不常见的方法？欢迎在评论区分享交流！如果觉得本文有帮助，不妨点赞收藏支持一下。

本文已收录到 Python 系列教程。上一篇：Python 字符串操作完全指南