ary += ext创建一个新的List对象，然后将列表“ary”和“ext”中的数据复制到其中。

ary.extend(ext)只是将对“ext”列表的引用添加到“ary”列表的末尾，从而减少内存事务。

因此，.extend的工作速度快了几个数量级，并且不使用被扩展的列表和被扩展的列表之外的任何额外内存。

╰─➤ time ./list_plus.py
./list_plus.py  36.03s user 6.39s system 99% cpu 42.558 total
╰─➤ time ./list_extend.py
./list_extend.py  0.03s user 0.01s system 92% cpu 0.040 total

第一个脚本也使用了超过200MB的内存，而第二个脚本只使用了一个“裸”python3进程的内存。

话虽如此，原地添加似乎与.extend做的事情是一样的。

我查了官方的Python教程，但找不到任何关于这个主题的东西

这个信息恰好隐藏在编程FAQ中:

．.． 对于列表，__iadd__[即+=]等价于在列表上调用extend并返回列表。这就是为什么我们说对于列表，+=是list.extend的“简写”

你也可以在CPython源代码中看到这一点:https://github.com/python/cpython/blob/v3.8.2/Objects/listobject.c#L1000-L1011

字节码级别上的唯一区别是.extend方式涉及到一个函数调用，在Python中这比INPLACE_ADD方法稍微昂贵一些。

这真的没什么好担心的，除非你做了几十亿次这个操作。然而，瓶颈很可能存在于其他地方。

ary += ext创建一个新的List对象，然后将列表“ary”和“ext”中的数据复制到其中。

ary.extend(ext)只是将对“ext”列表的引用添加到“ary”列表的末尾，从而减少内存事务。

因此，.extend的工作速度快了几个数量级，并且不使用被扩展的列表和被扩展的列表之外的任何额外内存。

╰─➤ time ./list_plus.py
./list_plus.py  36.03s user 6.39s system 99% cpu 42.558 total
╰─➤ time ./list_extend.py
./list_extend.py  0.03s user 0.01s system 92% cpu 0.040 total

第一个脚本也使用了超过200MB的内存，而第二个脚本只使用了一个“裸”python3进程的内存。

话虽如此，原地添加似乎与.extend做的事情是一样的。

实际上，ADD、INPLACE_ADD和extend这三个选项是有区别的。前者总是比较慢，而其他两种大致相同。

有了这些信息，我宁愿使用extend，它比ADD快，而且在我看来，它比INPLACE_ADD更能清楚地说明您在做什么。

试几次下面的代码(适用于Python 3):

import time

def test():
    x = list(range(10000000))
    y = list(range(10000000))
    z = list(range(10000000))

    # INPLACE_ADD
    t0 = time.process_time()
    z += x
    t_inplace_add = time.process_time() - t0

    # ADD
    t0 = time.process_time()
    w = x + y
    t_add = time.process_time() - t0

    # Extend
    t0 = time.process_time()
    x.extend(y)
    t_extend = time.process_time() - t0

    print('ADD {} s'.format(t_add))
    print('INPLACE_ADD {} s'.format(t_inplace_add))
    print('extend {} s'.format(t_extend))
    print()

for i in range(10):
    test()

ADD 0.3540440000000018 s
INPLACE_ADD 0.10896000000000328 s
extend 0.08370399999999734 s

ADD 0.2024550000000005 s
INPLACE_ADD 0.0972940000000051 s
extend 0.09610200000000191 s

ADD 0.1680199999999985 s
INPLACE_ADD 0.08162199999999586 s
extend 0.0815160000000077 s

ADD 0.16708400000000267 s
INPLACE_ADD 0.0797719999999913 s
extend 0.0801490000000058 s

ADD 0.1681250000000034 s
INPLACE_ADD 0.08324399999999343 s
extend 0.08062700000000689 s

ADD 0.1707760000000036 s
INPLACE_ADD 0.08071900000000198 s
extend 0.09226200000000517 s

ADD 0.1668420000000026 s
INPLACE_ADD 0.08047300000001201 s
extend 0.0848089999999928 s

ADD 0.16659500000000094 s
INPLACE_ADD 0.08019399999999166 s
extend 0.07981599999999389 s

ADD 0.1710910000000041 s
INPLACE_ADD 0.0783479999999912 s
extend 0.07987599999999873 s

ADD 0.16435900000000458 s
INPLACE_ADD 0.08131200000001115 s
extend 0.0818660000000051 s

对于非局部变量(对于函数来说不是局部变量，也不是全局变量)不能使用+=

def main():
    l = [1, 2, 3]

    def foo():
        l.extend([4])

    def boo():
        l += [5]

    foo()
    print l
    boo()  # this will fail

main()

这是因为对于扩展情况编译器将使用LOAD_DEREF指令加载变量l，但对于+=它将使用LOAD_FAST -并且你得到*UnboundLocalError:局部变量'l'在赋值之前引用*