Python列表增元素：append、extend与insert区别

脚本专家

Python列表中增加元素看似简单，但 append、insert、extend 和切片赋值在添加位置、添加数量、时间复杂度和返回值上差异很大。很多问题不是 API 不会用，而是选错方式导致结果不符合预期，甚至出现性能瓶颈。

一、append：末尾追加单个元素
append 把一个对象追加到列表末尾，是最常用的方式。它只添加一个元素，即使参数是列表，也只会把整个列表当成一个元素。

2. fruits = ['苹果', '香蕉']
3. fruits.append('橘子')
4. print(fruits)  # ['苹果', '香蕉', '橘子']
6. fruits.append(42)
7. fruits.append([1, 2, 3])
8. fruits.append({'key': 'value'})
9. print(fruits)
10. # ['苹果', '香蕉', '橘子', 42, [1, 2, 3], {'key': 'value'}]

复制代码

append 的关键：append(x) 等价于 lst[len(lst):] = [x]，总是在末尾添加一个元素。不要用 append 添加多个元素：

2. nums = [1, 2, 3]
3. nums.append([4, 5])
4. print(nums)      # [1, 2, 3, [4, 5]]
5. print(len(nums)) # 4

复制代码

另外，append 返回 None，不是修改后的列表。写成 nums = nums.append(5) 会让 nums 变成 None。

2. nums = [1, 2, 3]
3. result = nums.append(4)
4. print(result) # None
5. print(nums)   # [1, 2, 3, 4]

复制代码

append 平均时间复杂度为 O(1)。Python 列表采用过度分配策略，不是每次追加都重新申请内存。

二、insert：在指定索引前插入
insert(i, x) 把 x 插入到当前索引 i 的元素之前，插入后 x 的索引为 i，原来的 lst[i:] 向后移动。

2. fruits = ['苹果', '香蕉', '橘子']
3. fruits.insert(1, '葡萄')
4. print(fruits) # ['苹果', '葡萄', '香蕉', '橘子']
6. fruits.insert(0, '西瓜')
7. print(fruits) # ['西瓜', '苹果', '葡萄', '香蕉', '橘子']

复制代码

索引规则：i 超过长度时插到末尾；i 小于 -len(lst) 时插到开头。

2. lst = [10, 20, 30, 40, 50]
3. lst.insert(2, 99)
4. print(lst) # [10, 20, 99, 30, 40, 50]
6. lst.insert(100, 999)
7. print(lst) # [10, 20, 99, 30, 40, 50, 999]
9. lst.insert(-100, -999)
10. print(lst) # [-999, 10, 20, 99, 30, 40, 50, 999]

复制代码

insert 的时间复杂度是 O(n)，因为插入位置后面的元素都要移动。频繁在头部插入时，性能会很差。需要头部频繁插入时，应使用 collections.deque：

2. from collections import deque
3. dq = deque()
4. dq.appendleft('a')
5. dq.appendleft('b')
6. dq.appendleft('c')
7. print(list(dq)) # ['c', 'b', 'a']

复制代码

三、extend：批量追加可迭代对象
extend(iterable) 把可迭代对象中的每个元素逐个追加到列表末尾。列表、元组、字符串、range、集合、字典、生成器都可以。

2. nums = [1, 2, 3]
3. nums.extend([4, 5, 6])
4. print(nums) # [1, 2, 3, 4, 5, 6]
6. nums.extend((7, 8))
7. print(nums) # [1, 2, 3, 4, 5, 6, 7, 8]
9. nums.extend('abc')
10. print(nums) # [1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c']
12. nums.extend(range(10, 13))
13. print(nums) # [1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c', 10, 11, 12]

复制代码

extend 与 append 的区别：

2. lst1 = [1, 2, 3]
3. lst1.append([4, 5])
4. print(lst1) # [1, 2, 3, [4, 5]]
6. lst2 = [1, 2, 3]
7. lst2.extend([4, 5])
8. print(lst2) # [1, 2, 3, 4, 5]

复制代码

extend 原地修改列表；+ 运算符会创建新列表；+= 通常等价于 extend，调用 __iadd__，而 lst = lst + iterable 调用 __add__ 创建新列表。

2. lst3 = [1, 2, 3]
3. lst4 = lst3 + [4, 5]
4. print(lst3) # [1, 2, 3]
5. print(lst4) # [1, 2, 3, 4, 5]
7. lst3.extend([4, 5])
8. print(lst3) # [1, 2, 3, 4, 5]

复制代码

性能上，extend 通常比循环 append 快，因为循环在 C 层面完成；但如果是从头创建列表，列表推导式往往更快。

四、切片赋值：最灵活的插入方式
切片赋值可以在任意位置插入任意数量元素，语法是 lst[a:a] = iterable。

2. nums = [1, 5, 9]
3. nums[1:1] = [2, 3, 4]
4. print(nums) # [1, 2, 3, 4, 5, 9]
6. nums[:0] = [-2, -1, 0]
7. print(nums) # [-2, -1, 0, 1, 2, 3, 4, 5, 9]
9. nums[len(nums):] = [10, 11, 12]
10. print(nums) # [-2, -1, 0, 1, 2, 3, 4, 5, 9, 10, 11, 12]

复制代码

切片插入和 extend 一样接受任何可迭代对象，也可以插入生成器；插入空序列等于什么都不做。

2. lst = [1, 6]
3. lst[1:1] = (2, 3, 4, 5)
4. print(lst) # [1, 2, 3, 4, 5, 6]
6. lst[1:1] = (x ** 2 for x in range(3))
7. print(lst) # [1, 0, 1, 4, 2, 3, 4, 5, 6]

复制代码

五、四种方式对比
功能对比：

2. goal = [1, 2, 3, 4, 5]
4. result1 = [1, 2, 3]
5. result1.append(4)
6. result1.append(5)
7. print(f'append: {result1}')
9. result2 = [1, 3, 4, 5]
10. result2.insert(1, 2)
11. print(f'insert: {result2}')
13. result3 = [1, 2]
14. result3.extend([3, 4, 5])
15. print(f'extend: {result3}')
17. result4 = [1, 5]
18. result4[1:1] = [2, 3, 4]
19. print(f'切片: {result4}')

复制代码

对比表：
方法 | 添加位置 | 添加数量 | 时间复杂度 | 返回值
append(x) | 末尾 | 1个（x本身） | O(1) | None
insert(i,x) | 指定索引i之前 | 1个（x本身） | O(n) | None
extend(it) | 末尾 | N个（展开） | O(k) | None
lst[a:a]=it | 指定位置 | 任意 | O(n) | None

性能方面，尾部追加用 append 循环和 extend 一次性追加，extend 通常更快；头部插入 list.insert(0) 比 deque.appendleft 慢很多。原文示例中 100000 次尾部追加和 10000 次头部插入都显示了明显差距。

六、实战：构建列表与分页累积
用不同方式构建 [0, 1, 4, 9, 16, 25]：

2. squares1 = []
3. for i in range(6):
4.     squares1.append(i ** 2)
5. print(squares1) # [0, 1, 4, 9, 16, 25]
7. squares2 = []
8. squares2.extend(i ** 2 for i in range(6))
9. print(squares2) # [0, 1, 4, 9, 16, 25]
11. squares5 = [i ** 2 for i in range(6)]
12. print(squares5) # [0, 1, 4, 9, 16, 25]

复制代码

Builder 模式可以用 append 和 extend 逐步构建列表：

2. class ListBuilder:
3.     '''用append模式逐步构建列表——类似StringBuilder'''
4.     def __init__(self):
5.         self._items = []
7.     def add(self, item):
8.         self._items.append(item)
9.         return self
11.     def add_all(self, items):
12.         self._items.extend(items)
13.         return self
15.     def build(self):
16.         return self._items[:]
18. result = (ListBuilder()
19.           .add('表头')
20.           .add_all(range(1, 5))
21.           .add('表尾')
22.           .build())
23. print(result) # ['表头', 1, 2, 3, 4, '表尾']

复制代码

分页查询结果累积适合用 extend：

2. def query_users(db_connection, conditions):
3.     all_results = []
4.     page = 1
5.     page_size = 100
6.     while True:
7.         start = (page - 1) * page_size + 1
8.         end = start + page_size
9.         results = [f'用户{i}' for i in range(start, min(end, start + 1000))]
10.         if not results:
11.             break
12.         all_results.extend(results)
13.         page += 1
14.         if page > 3:
15.             break
16.     return all_results
18. users = query_users(None, {})
19. print(f'共查询到 {len(users)} 个用户')

复制代码

七、常见错误与最佳实践
错误一：append 和 extend 混淆。append([4,5]) 添加整个列表，extend([4,5]) 才展开添加两个元素。
错误二：在循环中用 insert 构建列表，会变成 O(n^2)。应先用 append，最后 reverse，或者使用 deque。
错误三：忘记 append 返回 None。nums = [1,2].append(3) 会让 nums 变成 None。
错误四：对元组调用 append。元组不可变，会抛 AttributeError。
错误五：多线程中复合操作不加锁。append 本身受 GIL 保护，但“检查再添加”等复合操作仍需要 lock。

最佳实践：
添加单个元素到末尾：append()
添加多个元素到末尾：extend() 或 +=
在指定位置插入一个元素：insert()
在指定位置插入多个元素：切片赋值
频繁头部插入：collections.deque
从零构建列表：列表推导式

这四种方式都返回 None，因为都是原地修改列表。理解添加位置、添加数量和复杂度后，选型就不容易出错。