详细介绍一下Python中列表的增删改操作

原创

程序员老彭

发布于 2025-11-16 09:57:45

4850

Python 列表（List）的核心特性是 可变性，支持动态添加、删除、修改元素，且操作简洁直观。以下从 添加元素、删除元素、修改元素 三大场景，结合 方法详解、代码示例、适用场景、注意事项 展开，覆盖所有高频操作，方便直接落地使用。

一、添加元素操作（3种核心方法）

列表添加元素的核心是 append()、extend()、insert()，三者功能互补，覆盖“单个添加、批量添加、指定位置添加”场景。

1. `append(x)`：末尾添加单个元素（最常用）

功能

在列表末尾追加 1 个元素，直接修改原列表，无返回值（返回 None）。

语法

list.append(x)

x：可以是任意类型（数字、字符串、列表、字典等，支持异构元素）。

代码示例

# 普通元素添加
fruits = ["苹果", "香蕉"]
fruits.append("橙子")
print(fruits)  # 输出：['苹果', '香蕉', '橙子']

# 添加异构元素（列表、字典）
fruits.append([100, 200])  # 添加列表（作为单个元素）
fruits.append({"price": 5.9})  # 添加字典（作为单个元素）
print(fruits)  # 输出：['苹果', '香蕉', '橙子', [100, 200], {'price': 5.9}]

适用场景

只需在列表末尾添加 1 个元素（无论类型）；
效率最高（时间复杂度 O(1)，直接在列表尾部扩容）。

注意事项

若 x 是列表/元组等可迭代对象，会被当作 单个元素 整体添加（而非拆分），如需拆分批量添加，用 extend()。

2. `extend(iterable)`：批量添加可迭代对象元素

功能

将 可迭代对象（列表、元组、字符串、集合等） 的所有元素，逐个添加到原列表末尾，直接修改原列表。

语法

list.extend(iterable)

iterable：必须是可迭代对象（不能是单个数字/布尔值，否则报错）。

代码示例

fruits = ["苹果", "香蕉"]

# 1. 列表作为可迭代对象（批量添加元素）
fruits.extend(["橙子", "葡萄"])
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '葡萄']

# 2. 元组作为可迭代对象
fruits.extend(("芒果", "梨"))
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '葡萄', '芒果', '梨']

# 3. 字符串作为可迭代对象（按字符拆分添加）
fruits.extend("西瓜")
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '葡萄', '芒果', '梨', '西', '瓜']

# 4. 集合作为可迭代对象（无序，去重）
fruits.extend({1, 2, 2, 3})
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '葡萄', '芒果', '梨', '西', '瓜', 1, 2, 3]

适用场景

批量添加多个元素（需拆分可迭代对象）；
效率高于循环 append()（内部优化，避免多次扩容）。

注意事项

若传入非可迭代对象（如 extend(5)），会抛出 TypeError: 'int' object is not iterable；
集合作为参数时，因无序性，添加的元素顺序不确定。

3. `insert(index, x)`：指定索引位置插入元素

功能

在列表的 指定索引 index 处 插入 1 个元素 x，原索引及后续元素统一后移，直接修改原列表。

语法

list.insert(index, x)

index：插入位置的索引（允许负数，-1 表示插入到倒数第二个位置）；
x：任意类型元素（单个元素，不拆分）。

代码示例

fruits = ["苹果", "香蕉", "橙子"]

# 1. 正向索引插入（索引1处插入）
fruits.insert(1, "梨")  # 插入后，原索引1及以后元素后移
print(fruits)  # 输出：['苹果', '梨', '香蕉', '橙子']

# 2. 反向索引插入（-1 表示倒数第二个位置）
fruits.insert(-1, "葡萄")
print(fruits)  # 输出：['苹果', '梨', '香蕉', '葡萄', '橙子']

# 3. 索引超出范围（自动插入到末尾）
fruits.insert(10, "芒果")  # 索引10远超列表长度（当前长度5）
print(fruits)  # 输出：['苹果', '梨', '香蕉', '葡萄', '橙子', '芒果']

适用场景

需要在列表中间或指定位置插入元素（如在第 2 个元素后添加新元素）。

注意事项

效率较低（时间复杂度 O(n)，需移动后续所有元素），频繁插入建议用链表（Python 无内置链表，可自定义或用 collections.deque）；
若 index >= len(list)，自动插入到列表末尾（等价于 append(x)）；
若 index <= -len(list)-1，自动插入到列表开头。

二、删除元素操作（4种核心方法/语法）

列表删除元素的核心是 del 语法、remove(x)、pop(index)、clear()，覆盖“按索引删、按值删、删并返回、清空列表”场景。

1. `del list[index]`：按索引删除元素（最灵活）

功能

通过索引直接删除元素，支持单个元素删除、切片批量删除，直接修改原列表。

语法

# 单个元素删除
del list[index]

# 切片批量删除
del list[start:end:step]

代码示例

fruits = ["苹果", "梨", "香蕉", "葡萄", "橙子", "芒果"]

# 1. 按正向索引删除（删除索引2的"香蕉"）
del fruits[2]
print(fruits)  # 输出：['苹果', '梨', '葡萄', '橙子', '芒果']

# 2. 按反向索引删除（删除倒数第二个"橙子"）
del fruits[-2]
print(fruits)  # 输出：['苹果', '梨', '葡萄', '芒果']

# 3. 切片批量删除（删除索引1~2的元素）
del fruits[1:3]
print(fruits)  # 输出：['苹果', '芒果']

# 4. 切片全量删除（清空列表，保留列表对象）
del fruits[:]
print(fruits)  # 输出：[]

适用场景

知道元素的索引（单个或批量）；
需彻底删除元素（无返回值，直接从内存中移除）。

注意事项

索引越界会抛出 IndexError: list index out of range，需先判断索引有效性（如 if 0 <= index < len(list)）；
切片删除时，即使范围超出列表长度，也不会报错（如 del fruits[10:20] 无效果）。

2. `remove(x)`：按值删除元素（第一个匹配项）

功能

在列表中查找 第一个匹配值 x

语法

list.remove(x)

代码示例

fruits = ["苹果", "香蕉", "橙子", "香蕉", "葡萄"]

# 1. 删除第一个"香蕉"
fruits.remove("香蕉")
print(fruits)  # 输出：['苹果', '橙子', '香蕉', '葡萄']

# 2. 删除不存在的元素（报错）
# fruits.remove("芒果")  # ValueError: list.remove(x): x not in list

适用场景

知道元素的值，但不知道索引，且列表中存在该元素；
只需删除第一个匹配项（如需删除所有匹配项，需循环判断）。

注意事项

元素不存在会抛出 ValueError，建议先通过 in 判断：

if "芒果" in fruits:
    fruits.remove("芒果")
else:
    print("元素不存在")

时间复杂度 O(n)（需遍历列表查找元素），效率低于按索引删除。

3. `pop(index)`：按索引删除并返回元素

功能

按索引删除元素（默认删除最后一个元素），并 返回被删除的元素，直接修改原列表。

语法

# 删除最后一个元素（默认 index=-1）
list.pop()

# 按索引删除元素
list.pop(index)

代码示例

fruits = ["苹果", "梨", "香蕉", "葡萄"]

# 1. 无参数（删除最后一个元素，返回该元素）
last_fruit = fruits.pop()
print(last_fruit)  # 输出：葡萄
print(fruits)      # 输出：['苹果', '梨', '香蕉']

# 2. 按索引删除（删除索引1的"梨"，返回该元素）
pop_fruit = fruits.pop(1)
print(pop_fruit)  # 输出：梨
print(fruits)     # 输出：['苹果', '香蕉']

# 3. 按反向索引删除（删除倒数第一个元素）
fruits.pop(-1)
print(fruits)  # 输出：['苹果']

适用场景

需要删除元素并同时获取该元素（如栈结构的“弹出”操作，LIFO）；
既想按索引删除，又想拿到删除的值（区别于 del 无返回值）。

注意事项

索引越界会抛出 IndexError，需提前判断；
无参数时效率最高（O(1)），按索引删除时效率 O(n)（需移动后续元素）。

4. `clear()`：清空列表所有元素

功能

删除列表中的 所有元素，保留列表对象（列表长度变为 0），直接修改原列表。

语法

list.clear()

代码示例

fruits = ["苹果", "香蕉", "橙子"]
fruits.clear()
print(fruits)  # 输出：[]
print(len(fruits))  # 输出：0

适用场景

需重置列表（保留列表对象，后续可重新添加元素）；
区别于 del list（直接删除列表对象，后续无法再使用该变量）。

注意事项

clear() 仅清空元素，不删除列表本身；del list 会彻底销毁列表对象，后续引用会报错。

三、修改元素操作（2种核心方式）

列表修改元素的核心是 索引赋值（单个元素修改）和 切片赋值（批量元素修改），直接修改原列表。

1. 索引赋值：修改单个元素

功能

通过索引定位单个元素，直接赋值替换，修改原列表。

语法

list[index] = new_value

new_value：任意类型元素（支持异构替换）。

代码示例

nums = [1, 2, 3, 4, 5]

# 1. 正向索引修改（修改索引2的元素）
nums[2] = 30
print(nums)  # 输出：[1, 2, 30, 4, 5]

# 2. 反向索引修改（修改倒数第二个元素）
nums[-2] = 40
print(nums)  # 输出：[1, 2, 30, 40, 5]

# 3. 异构元素替换（数字→字符串）
nums[0] = "Python"
print(nums)  # 输出：['Python', 2, 30, 40, 5]

适用场景

只需修改列表中单个元素（知道索引）。

注意事项

索引越界会抛出 IndexError，需提前判断。

2. 切片赋值：批量修改多个元素

功能

通过切片定位一段元素，用新的可迭代对象替换，支持“长度一致替换”和“长度不一致替换”（自动调整列表长度）。

语法

list[start:end:step] = new_iterable

new_iterable：可迭代对象（列表、元组、字符串等，若为单个元素需包装成可迭代对象）。

代码示例

nums = [1, 2, 3, 4, 5, 6]

# 1. 长度一致替换（索引1~3的元素→[20, 30, 40]）
nums[1:4] = [20, 30, 40]
print(nums)  # 输出：[1, 20, 30, 40, 5, 6]

# 2. 长度不一致替换（索引4~5的2个元素→[50, 60, 70]的3个元素，列表变长）
nums[4:] = [50, 60, 70]
print(nums)  # 输出：[1, 20, 30, 40, 50, 60, 70]

# 3. 切片删除（用空列表替换，等价于 del nums[1:3]）
nums[1:3] = []
print(nums)  # 输出：[1, 40, 50, 60, 70]

# 4. 字符串作为可迭代对象替换（按字符拆分）
nums[2:4] = "AB"
print(nums)  # 输出：[1, 40, 'A', 'B', 70]

适用场景

批量修改列表中一段连续的元素；
批量删除一段元素（用空列表替换）；
批量插入元素（切片范围为 start:start，如 nums[2:2] = [x, y] 表示在索引2处插入）。

注意事项

若 new_iterable 是单个非可迭代对象（如 nums[1:3] = 10），会抛出 TypeError，需包装成可迭代对象（如 nums[1:3] = [10]）；
步长 step != 1 时，替换的可迭代对象长度必须与切片长度一致，否则报错。

四、增删改操作总结表（快速查阅）

操作类型	方法/语法	核心功能	时间复杂度	适用场景
添加	append(x)	末尾添加单个元素	O(1)	单个元素末尾添加
添加	extend(iterable)	末尾批量添加可迭代对象元素	O(k)（k为迭代对象长度）	多个元素批量添加
添加	insert(index, x)	指定索引插入单个元素	O(n)	指定位置插入元素
删除	del list[index]	按索引删除单个/批量元素	O(n)	知道索引，彻底删除
删除	remove(x)	按值删除第一个匹配项	O(n)	知道值，删除第一个匹配项
删除	pop(index)	按索引删除并返回元素（默认删最后一个）	O(1)（无参）/ O(n)（有参）	删除并获取元素（栈操作）
删除	clear()	清空所有元素，保留列表对象	O(n)	重置列表
修改	list[index] = new_val	按索引修改单个元素	O(1)	修改单个元素
修改	list[start:end] = iter	按切片批量修改元素	O(n)	批量修改/插入/删除一段元素

五、常见避坑指南

索引越界：增删改时需确保索引在 [0, len(list)-1] 范围内，或用 try-except 捕获异常；
append() 与 extend() 混淆：批量添加可迭代对象元素用 extend()，添加单个元素（含列表）用 append()；
remove() 删重复元素：remove() 仅删第一个匹配项，如需删除所有重复项，用列表推导式：

nums = [1, 2, 2, 3, 2]
nums = [x for x in nums if x != 2]  # 输出：[1, 3]

列表作为函数参数的修改：列表是可变类型，函数内修改会影响原列表，如需避免，传列表副本（list.copy() 或 list[:]）；
切片赋值的可迭代要求：切片赋值的右侧必须是可迭代对象，单个元素需包装成列表/元组。

掌握以上增删改操作，就能灵活处理 Python 列表的大部分场景，也是后续学习数据处理、算法的基础核心技能。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

python

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

python

登录后参与评论

0 条评论

热度