【Python】List列表更新的四种常用方法

在 Python 中，list 是一种常用的数据结构，支持多种操作，比如 append、insert 和 update（实际上是通过索引直接修改）。以下是它们的区别和代码示例：

---

1. append

• 作用：在列表的末尾添加一个元素。
• 特点：只能添加到末尾，不能指定位置。
• 时间复杂度：O(1)。

代码示例：

my_list = [1, 2, 3]
my_list.append(4)  # 在列表末尾添加元素 4
print(my_list)     # 输出: [1, 2, 3, 4]

---

2. insert

• 作用：在列表的指定位置插入一个元素。
• 特点：可以指定插入的位置，插入位置后面的元素会向后移动。
• 时间复杂度：O(n)，因为需要移动元素。

代码示例：

my_list = [1, 2, 3]
my_list.insert(1, 10)  # 在索引 1 的位置插入元素 10
print(my_list)         # 输出: [1, 10, 2, 3]

---

3. update（通过索引直接修改）

• 作用：通过索引直接修改列表中某个位置的元素。
• 特点：需要指定索引，且索引必须在列表的有效范围内。
• 时间复杂度：O(1)。

代码示例：

my_list = [1, 2, 3]
my_list[1] = 20  # 将索引 1 的元素修改为 20
print(my_list)   # 输出: [1, 20, 3]

在 Python 的 list 中，除了 append、insert 和通过索引直接修改（update）之外，还有一些其他常用的方法可以实现类似的功能。以下是这些方法的介绍和代码示例：

---

4. extend

• 作用：将一个可迭代对象（如列表、元组、字符串等）的所有元素添加到列表的末尾。
• 特点：可以一次性添加多个元素。
• 时间复杂度：O(k)，其中 k 是被添加的可迭代对象的长度。

代码示例：

my_list = [1, 2, 3]
my_list.extend([4, 5])  # 将列表 [4, 5] 添加到末尾
print(my_list)          # 输出: [1, 2, 3, 4, 5]

---

总结对比：

操作	作用	特点	时间复杂度
append	在列表末尾添加元素	只能添加到末尾	O(1)
insert	在指定位置插入元素	可以指定位置，后面的元素会移动	O(n)
update	修改指定位置的元素	需要指定索引，直接覆盖原值	O(1)
extend	添加多个元素到列表末尾	可以一次性添加多个元素	O(k)

---

综合代码示例：

# 初始化列表
my_list = [1, 2, 3]

# 使用 append
my_list.append(4)
print("After append:", my_list)  # 输出: [1, 2, 3, 4]

# 使用 insert
my_list.insert(1, 10)
print("After insert:", my_list)  # 输出: [1, 10, 2, 3, 4]

# 使用 update
my_list[2] = 20
print("After update:", my_list)  # 输出: [1, 10, 20, 3, 4]

关于list的其他一些常用功能方法：

1. del 语句

• 作用：通过索引或切片删除列表中的元素。
• 特点：可以直接删除某个元素或某个范围的元素。
• 时间复杂度：O(n)，因为可能需要移动元素。

代码示例：

my_list = [1, 2, 3, 4, 5]
del my_list[1]      # 删除索引 1 的元素
print(my_list)      # 输出: [1, 3, 4, 5]

del my_list[1:3]    # 删除索引 1 到 2 的元素
print(my_list)      # 输出: [1, 5]

2. + 运算符

• 作用：通过 + 运算符将两个列表合并，生成一个新的列表。
• 特点：不会修改原列表，而是返回一个新的列表。
• 时间复杂度：O(n + m)，其中 n 和 m 是两个列表的长度。

代码示例：

my_list = [1, 2, 3]
new_list = my_list + [4, 5]  # 合并两个列表
print(new_list)              # 输出: [1, 2, 3, 4, 5]
print(my_list)               # 原列表不变，输出: [1, 2, 3]

---

3. * 运算符

• 作用：通过 * 运算符将列表重复多次，生成一个新的列表。
• 特点：不会修改原列表，而是返回一个新的列表。
• 时间复杂度：O(n * k)，其中 n 是列表的长度，k 是重复的次数。

代码示例：

my_list = [1, 2]
new_list = my_list * 3  # 将列表重复 3 次
print(new_list)         # 输出: [1, 2, 1, 2, 1, 2]
print(my_list)          # 原列表不变，输出: [1, 2]

---

4. slice 切片操作

• 作用：通过切片操作可以修改列表的某一部分。
• 特点：可以一次性修改多个元素。
• 时间复杂度：O(k)，其中 k 是切片操作涉及的元素数量。

代码示例：

my_list = [1, 2, 3, 4, 5]
my_list[1:3] = [20, 30]  # 将索引 1 到 2 的元素替换为 [20, 30]
print(my_list)           # 输出: [1, 20, 30, 4, 5]

---

5. remove

• 作用：删除列表中第一个匹配的元素。
• 特点：需要指定元素的值，如果元素不存在会抛出 ValueError。
• 时间复杂度：O(n)，因为需要遍历列表。

代码示例：

my_list = [1, 2, 3, 2]
my_list.remove(2)  # 删除第一个值为 2 的元素
print(my_list)     # 输出: [1, 3, 2]

---

6. pop

• 作用：删除并返回指定索引位置的元素（默认删除最后一个元素）。
• 特点：可以指定索引，如果不指定索引则删除最后一个元素。
• 时间复杂度：O(1)（删除末尾元素）或 O(n)（删除中间元素）。

代码示例：

my_list = [1, 2, 3, 4]
popped_value = my_list.pop(1)  # 删除索引 1 的元素
print("Popped value:", popped_value)  # 输出: 2
print("List after pop:", my_list)     # 输出: [1, 3, 4]

---

7. clear

• 作用：清空列表中的所有元素。
• 特点：直接修改原列表，使其变为空列表。
• 时间复杂度：O(1)。

代码示例：

my_list = [1, 2, 3]
my_list.clear()  # 清空列表
print(my_list)   # 输出: []

---