在 Python 中，“.append()”和“+= []”有啥区别？

Posted 2023-02-24

【中文标题】在 Python 中，“.append()”和“+= []”有啥区别？

【英文标题】：In Python, what is the difference between ".append()" and "+= []"?在 Python 中，“.append()”和“+= []”有什么区别？

【发布时间】：2010-10-18 01:38:16

【问题描述】：

有什么区别：

some_list1 = []
some_list1.append("something")

和

some_list2 = []
some_list2 += ["something"]

【问题讨论】：

如果为单个项目附加。也许你的意思是extend。

+= vs extend 更有趣的案例：***.com/questions/3653298/…

+= vs append ***.com/q/252703/6674599

【参考方案1】：

对于您的情况，唯一的区别是性能：追加速度是原来的两倍。

Python 3.0 (r30:67507, Dec  3 2008, 20:14:27) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.Timer('s.append("something")', 's = []').timeit()
0.20177424499999999
>>> timeit.Timer('s += ["something"]', 's = []').timeit()
0.41192320500000079

Python 2.5.1 (r251:54863, Apr 18 2007, 08:51:08) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.Timer('s.append("something")', 's = []').timeit()
0.23079359499999999
>>> timeit.Timer('s += ["something"]', 's = []').timeit()
0.44208112500000141

一般情况下，append 会将一项添加到列表中，而+= 会将右侧列表的所有元素复制到左侧列表中。 p>

更新：性能分析

比较字节码，我们可以假设append 版本在LOAD_ATTR + CALL_FUNCTION 中浪费了周期，而在BUILD_LIST 中+= 版本浪费了周期。显然BUILD_LIST 超过LOAD_ATTR + CALL_FUNCTION。

>>> import dis
>>> dis.dis(compile("s = []; s.append('spam')", '', 'exec'))
  1           0 BUILD_LIST               0
              3 STORE_NAME               0 (s)
              6 LOAD_NAME                0 (s)
              9 LOAD_ATTR                1 (append)
             12 LOAD_CONST               0 ('spam')
             15 CALL_FUNCTION            1
             18 POP_TOP
             19 LOAD_CONST               1 (None)
             22 RETURN_VALUE
>>> dis.dis(compile("s = []; s += ['spam']", '', 'exec'))
  1           0 BUILD_LIST               0
              3 STORE_NAME               0 (s)
              6 LOAD_NAME                0 (s)
              9 LOAD_CONST               0 ('spam')
             12 BUILD_LIST               1
             15 INPLACE_ADD
             16 STORE_NAME               0 (s)
             19 LOAD_CONST               1 (None)
             22 RETURN_VALUE

我们可以通过移除LOAD_ATTR 开销来进一步提高性能：

>>> timeit.Timer('a("something")', 's = []; a = s.append').timeit()
0.15924410999923566

【讨论】：

+1：这很有趣。无论如何我都使用 append，因为它会产生更清晰的代码。但我没有意识到存在性能差异。如果有的话，我预计 append 会更慢，因为它是一个有保证的函数调用，而我认为 += 会进一步优化。

不也有功能上的区别吗？例如 let a = [], b = [4,5,6]，如果你这样做 c = a.append(b) 那么 c 将是列表 [[4,5,6]] 而 c += b 的列表；将导致一个简单的列表 c = [4,5,6]。

只是为了让事情变得简单：只要您的输入格式正确，+= 比扩展或附加提供更好的性能。在当前示例中需要时间的是创建 ['something'] 列表。 += 大约快 15%

@Joe 如果您要比较 append 与 +=，那么您必须将列表的创建作为衡量的一部分。否则，这将是一个不同的问题（extend vs +=）。

@jamesdlin 是的！但除非你已经知道这一点，否则很容易出错。一点额外的精确度不会伤害任何人，对吧？

【参考方案2】：

在您给出的示例中，append 和+= 在输出方面没有区别。但是append 和+ 之间是有区别的（这个问题最初是问的）。

>>> a = []
>>> id(a)
11814312
>>> a.append("hello")
>>> id(a)
11814312

>>> b = []
>>> id(b)
11828720
>>> c = b + ["hello"]
>>> id(c)
11833752
>>> b += ["hello"]
>>> id(b)
11828720

如您所见，append 和 += 的结果相同；他们将项目添加到列表中，而不生成新列表。使用+ 添加两个列表并生成一个新列表。

【讨论】：

追加和+=之间有的区别。

事实上，append 将一个条目添加到列表中，而 += 会添加与另一个列表中的条目一样多的条目（即 extend 的别名）。但是他/她已经知道了，从问题的写法来看。我还缺少其他一些区别吗？

有所不同，因为扩充的作业引入了重新绑定（在我的回答中进行了解释）。

【参考方案3】：

>>> a=[]
>>> a.append([1,2])
>>> a
[[1, 2]]
>>> a=[]
>>> a+=[1,2]
>>> a
[1, 2]

看到 append 将单个元素添加到列表中，它可以是任何元素。 +=[] 加入列表。

【讨论】：

投票赞成，因为这是两者之间的重要区别。干得好。

【参考方案4】：

+= 是一个赋值。当你使用它时，你实际上是在说‘some_list2= some_list2+['something']'。作业涉及重新绑定，所以：

l= []

def a1(x):
    l.append(x) # works

def a2(x):
    l= l+[x] # assign to l, makes l local
             # so attempt to read l for addition gives UnboundLocalError

def a3(x):
    l+= [x]  # fails for the same reason

+= 运算符通常也应该像 list+list 通常那样创建一个新的列表对象：

>>> l1= []
>>> l2= l1

>>> l1.append('x')
>>> l1 is l2
True

>>> l1= l1+['x']
>>> l1 is l2
False

但实际上：

>>> l2= l1
>>> l1+= ['x']
>>> l1 is l2
True

这是因为 Python 列表实现了 __iadd__() 以使 += 增强赋值短路并改为调用 list.extend()。 （这有点奇怪：它通常按照您的意思执行，但原因令人困惑。）

一般来说，如果您要附加/扩展现有列表，并且希望保留对同一列表的引用（而不是创建新列表），最好明确并坚持使用 append()/ extend() 方法。

【参考方案5】：

 some_list2 += ["something"]

其实是

 some_list2.extend(["something"])

对于一个值，没有区别。 文档指出：

s.append(x) 与 s[len(s):len(s)] = [x] 相同 s.extend(x) 与 s[len(s):len(s)] = x 相同

因此显然s.append(x) 与s.extend([x]) 相同

【讨论】：

s.append 采用任意类型并将其添加到列表中；这是一个真正的附加。 s.extend 接受一个迭代（通常是一个列表），并将迭代合并到 s 中，修改 s 的内存地址。这些是不相同的。

【参考方案6】：

不同之处在于 concatenate 将展平结果列表，而 append 将保持级别不变：

例如：

myList = [ ]
listA = [1,2,3]
listB = ["a","b","c"]

使用追加，您最终会得到一个列表列表：

>> myList.append(listA)
>> myList.append(listB)
>> myList
[[1,2,3],['a',b','c']]

改为使用连接，您最终会得到一个平面列表：

>> myList += listA + listB
>> myList
[1,2,3,"a","b","c"]

【参考方案7】：

这里的性能测试不正确：

您不应只运行一次配置文件。 如果多次比较 append 和 +=[]，您应该将 append 声明为本地函数。 不同 python 版本的时间结果不同：64 位和 32 位。

例如

timeit.Timer('for i in xrange(100): app(i)', 's = [] ; app = s.append').timeit()

可以在这里找到好的测试：Python list append vs. +=[]

【讨论】：

仍然，该页面中的 += 测试使用 += [one_var]。如果我们省略创建列表，+= 将成为​​最快的选项。

【参考方案8】：

除了其他答案中描述的方面之外，当您尝试构建列表时， append 和 +[] 具有非常不同的行为。

>>> list1=[[1,2],[3,4]]
>>> list2=[5,6]
>>> list3=list1+list2
>>> list3
[[1, 2], [3, 4], 5, 6]
>>> list1.append(list2)
>>> list1
[[1, 2], [3, 4], [5, 6]]

list1+['5','6'] 将 '5' 和 '6' 作为单独的元素添加到 list1 中。 list1.append(['5','6']) 将列表 ['5','6'] 作为单个元素添加到 list1。

【参考方案9】：

其他答案中提到的重新绑定行为在某些情况下确实很重要：

>>> a = ([],[])
>>> a[0].append(1)
>>> a
([1], [])
>>> a[1] += [1]
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

这是因为增强赋值总是会重新绑定，即使对象在原地发生了变异。这里的重新绑定恰好是a[1] = *mutated list*，这对元组不起作用。

【参考方案10】：

"+" 不会改变列表

.append() 变异旧列表

【参考方案11】：

我们先举个例子

list1=[1,2,3,4]
list2=list1     (that means they points to same object)

if we do 
list1=list1+[5]    it will create a new object of list
print(list1)       output [1,2,3,4,5] 
print(list2)       output [1,2,3,4]

but if we append  then 
list1.append(5)     no new object of list created
print(list1)       output [1,2,3,4,5] 
print(list2)       output [1,2,3,4,5]

extend(list) also do the same work as append it just append a list instead of a 
single variable 

【参考方案12】：

append() 方法将单个项目添加到现有列表中

some_list1 = []
some_list1.append("something")

所以这里 some_list1 将被修改。

更新：

而使用 + 来组合现有列表中的列表元素（多个元素）类似于扩展（由 Flux 更正）。

some_list2 = []
some_list2 += ["something"]

所以这里 some_list2 和 ["something"] 是两个组合在一起的列表。

【讨论】：

这是错误的。 += 不返回新列表。 Programming FAQ 说：“...对于列表，__iadd__ 相当于在列表上调用 extend 并返回列表。这就是为什么我们说对于列表，+= 是 @987654330 的“简写” @"。你也可以在 CPython 源代码中看到这一点：github.com/python/cpython/blob/v3.8.2/Objects/…

【参考方案13】：

截至今天和 Python 3.6，@Constantine 提供的结果不再相同。

Python 3.6.10 |Anaconda, Inc.| (default, May  8 2020, 02:54:21) 
[GCC 7.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> timeit.Timer('s.append("something")', 's = []').timeit()
0.0447923709944007
>>> timeit.Timer('s += ["something"]', 's = []').timeit()
0.04335783299757168

似乎append 和+= 现在的性能相当，而编译差异根本没有改变：

>>> import dis
>>> dis.dis(compile("s = []; s.append('spam')", '', 'exec'))
  1           0 BUILD_LIST               0
              2 STORE_NAME               0 (s)
              4 LOAD_NAME                0 (s)
              6 LOAD_ATTR                1 (append)
              8 LOAD_CONST               0 ('spam')
             10 CALL_FUNCTION            1
             12 POP_TOP
             14 LOAD_CONST               1 (None)
             16 RETURN_VALUE
>>> dis.dis(compile("s = []; s += ['spam']", '', 'exec'))
  1           0 BUILD_LIST               0
              2 STORE_NAME               0 (s)
              4 LOAD_NAME                0 (s)
              6 LOAD_CONST               0 ('spam')
              8 BUILD_LIST               1
             10 INPLACE_ADD
             12 STORE_NAME               0 (s)
             14 LOAD_CONST               1 (None)
             16 RETURN_VALUE