Python列表怎么一次性追加多个元素？extend与+=的区别

在 Python 中，若想向已有列表中一次性追加多个元素，最标准且高效的做法是使用列表的 extend() 方法或 += 增量赋值运算符。二者均能就地（in-place）遍历指定的可迭代对象并将所有元素依次挂载至当前列表末尾，避免了重复调用单元素追加方法的高额开销。但在底层调用链路、语法解析和应对特殊数据结构时，它们存在细微却至关重要的差异。

一、一次性追加多个元素的常用实现

初学者容易尝试使用 append() 方法来添加列表，但 append() 的设计职责是将传入的参数作为单一整体元素追加至列表末尾，从而导致嵌套列表。要实现平铺式的批量追加，常用方法如下：

1. 使用 extend() 方法

list.extend(iterable) 是 Python 列表专门用于批量追加元素的内建方法。它接收一个可迭代对象，将其内部的每个元素逐个取出并添加到原列表中，该方法没有返回值（返回 None），属于原地修改。

# 示例代码：使用 extend 追加多个元素
numbers = [1, 2, 3]
numbers.extend([4, 5, 6])
print(numbers)
# 示例输出：[1, 2, 3, 4, 5, 6]

2. 使用 += 增量赋值运算符

对列表使用 += 运算时，Python 并不会创建新的列表对象，而是直接调用列表内部的 __iadd__ 魔法方法，其行为与 extend() 几乎一致，语法上更为简练紧凑。

# 示例代码：使用 += 追加多个元素
numbers = [1, 2, 3]
numbers += [4, 5, 6]
print(numbers)
# 示例输出：[1, 2, 3, 4, 5, 6]

3. 使用切片赋值（Slice Assignment）

利用列表末尾的切片 list[len(list):] = iterable 同样可以实现原地批量插入。这种方式兼容性强，但可读性不如 extend 直观。

# 示例代码：切片赋值追加
numbers = [1, 2, 3]
numbers[len(numbers):] = [4, 5, 6]
print(numbers)
# 示例输出：[1, 2, 3, 4, 5, 6]

图 1：列表追加元素的数据流向与参数拆解机制示意图

二、extend() 与 += 的共同点：原地修改机制

在性能和内存管理方面，extend() 和 += 最突出的特点就是原地修改（In-Place Modification）。它们直接在原有列表对象的底层动态数组上扩展空间并存入引用，而不会向内存申请创建全新的列表对象。

我们可以通过 Python 内建的 id() 函数打印对象在内存中的唯一地址来验证这一点：

# 示例代码：验证内存地址不变
list_a = [10, 20]
print("操作前 id:", id(list_a))

list_a.extend([30, 40])
print("extend 后的 id:", id(list_a))

list_a += [50, 60]
print("+= 后的 id:", id(list_a))

# 示例输出：三个 id 的数值完全一致，证明同一对象在内存中持续原地扩容

与之对比的是普通的加号运算符 +。使用 list_a = list_a + [70, 80] 会重新分配内存以生成一个全新的列表对象，把旧列表和新列表的元素全部拷贝一遍，再将变量绑定到新地址，其时间和空间复杂度在频繁操作时远高于 extend() 与 +=。

图 2：底层内存分配模型：原地扩容机制与新建列表机制的差异

三、extend() 与 += 的本质区别

尽管在绝大多数常规编码场景中 a.extend(b) 与 a += b 可以互相替代，但从底层语法、协议调用和防御性编程的角度审视，它们具有明显的不同。

1. 底层调用机制与字节码指令

extend() 是标准的对象方法调用。在 CPython 虚拟机执行时，对应的字节码主要是 LOAD_METHOD 和 CALL_METHOD。

而 += 是一个增量赋值运算符（Augmented Assignment）。在执行 a += b 时，虚拟机首先执行 INPLACE_ADD 指令。对列表来说，该指令触发 PyList_Type.tp_as_sequence->sq_inplace_concat，其底层直接转调了 list.extend，并把自身指针返回。随后，虚拟机执行 STORE_NAME 或 STORE_SUBSCR 将返回值重新赋值给左侧变量。

2. 经典深坑：包含在元组中的列表使用 += 报错却生效

这一区别在下面这个著名的 Python 面试与生产陷阱中体现得淋漓尽致：

# 经典陷阱代码
nested_tuple = ([1, 2], "hello")

try:
    nested_tuple[0] += [3, 4]
except TypeError as e:
    print("抛出异常:", e)

print("nested_tuple 当前结果:", nested_tuple)

# 示例输出：
# 抛出异常: 'tuple' object does not support item assignment
# nested_tuple 当前结果: ([1, 2, 3, 4], 'hello')

原因剖析：

1. 在执行 nested_tuple[0] += [3, 4] 时，分为两步：第一步是计算 nested_tuple[0] + [3, 4] 的就地修改，由于 nested_tuple[0] 是列表，INPLACE_ADD 成功将其内部追加为 [1, 2, 3, 4] 并返回该列表对象；
2. 第二步，+= 语法规则要求将结果重新写回左侧的容器位置（执行 STORE_SUBSCR）。但因为外层容器是元组（tuple），元组属于不可变对象，禁止下标赋值，因而抛出了 TypeError；
3. 最终造成了：既引发了异常，又修改了数据这一诡异现象。

如果我们改用 extend() 方法，则完全不会产生此问题：

nested_tuple = ([1, 2], "hello")
nested_tuple[0].extend([3, 4])
print(nested_tuple)
# 示例输出：([1, 2, 3, 4], 'hello')，平稳执行无报错

因为 extend() 仅仅是一个普通的方法调用，不存在“重新写回元组下标”的赋值动作，因此完全绕开了元组不可变的写回限制。

图 3：指令链路对比：元组只读检查为何在 += 场景下被触发

四、传入非列表可迭代对象时的表现

extend() 与 += 的另一个极其强大但偶尔会导致 Bug 的特性是：它们接受任意可迭代对象（Iterable），包括元组、集合、生成器甚至是字符串与字典。

# 示例代码：追加不同类型的可迭代对象
data = [1, 2]

# 1. 追加元组
data.extend((3, 4))

# 2. 追加集合
data += {5, 6}

# 3. 追加生成器表达式
data.extend(x * 10 for x in [1, 2])

print(data)
# 示例输出：[1, 2, 3, 4, 5, 6, 10, 20]

items = ["apple", "banana"]
items.extend("orange")
print(items)
# 示例输出：['apple', 'banana', 'o', 'r', 'a', 'n', 'g', 'e']
# 如果只想追加单一字符串，请使用 append() 或包裹在列表中 items.extend(["orange"])

五、综合选型与实践决策指南

在日常开发与工程架构中，应该如何在这几种方式中做出选择？下表归纳了它们的核心特性：

图 4：列表追加元素的技术选型决策路径图

六、总结

在 Python 中一次性追加多个元素时：

• 想要平铺添加多个元素，切勿使用 append()，而应使用 extend() 或 +=；
• extend() 与 += 都是就地（in-place）扩容，内存地址保持不变，执行效率高；
• += 触发 INPLACE_ADD 后会执行赋值回写，在处理嵌套于不可变容器（如元组）中的列表时会抛出异常；而 extend() 仅是纯粹的方法调用，具备更好的鲁棒性；
• 切记切勿写出 a = a.extend(b) 这样的代码，因为 extend() 返回 None，会导致原列表变量被置空。