在Python中，".append()"和"+=[]"之间有什么区别？

Question

什么是以下代码片段之间的区别：

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

以及

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

- Nope

---

如果只是针对单个项目，您可能想使用“扩展（extend）”而不是“追加（append）”。 - hasen

对于更有趣的 += vs extend 情况，请参考：https://dev59.com/inA65IYBdhLWcg3wvxaE - Ciro Santilli OurBigBook.com

+=与append的区别 https://dev59.com/w3VC5IYBdhLWcg3wjx_u - Semnodime

Answer 1

对于您的情况，唯一的区别是性能：append快两倍。

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会向列表中添加一个项目，而+=会将右侧列表的所有元素复制到左侧列表中。

更新：性能分析

比较字节码，我们可以假设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

- Constantin

---

这很有趣。我仍然使用append，因为它会产生更清晰的代码，但我并没有意识到性能上的差异。如果说有的话，我本来预期append会比+=更慢，因为它涉及一个保证的函数调用，而我认为+=会被更进一步地优化。 - DNS

这里是否还有一个功能上的差异呢？例如，让 **a = []，b = [4,5,6]**，如果你执行 **c = a.append(b)**，那么 c 将是一个列表嵌套列表的形式 **[[4,5,6]]**，而 c += b 则会得到一个简单的列表 **c = [4,5,6]**。 - rph

只是为了澄清一下：只要输入格式正确，+=比extend或append提供更好的性能。在当前示例中需要时间的是创建['something']列表。 +=快大约15%。 - Joe

@Joe 如果你正在比较append和+=，那么你必须将列表的创建作为测量的一部分。否则这将是一个不同的问题（extend vs +=）。 - jamesdlin

@jamesdlin 是的！但是如果你不知道这一点，很容易被误解。多一点额外的精确度从来没有伤害过任何人，对吧？ - Joe

@rph 没有功能上的区别。为了回答问题，你的例子应该是 c += [b] 而不是 c += b，所以你漏掉了括号。 - matheburg

Answer 2

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

看到这里，append 是将一个元素添加到列表中，而这个元素可以是任何东西。+=[]则是将两个列表连接在一起。

- dwc

---

点赞，因为这是两者之间的重要区别。干得好。 - user13876

Answer 3

在你提供的例子中，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 和 += 的效果是相同的；它们都会将项目添加到列表中，同时不会生成新的列表。而使用+会将两个列表拼接并生成一个新的列表。

- DNS

---

+= 和 append() 之间是有区别的。 - Constantin

append 方法会向列表中添加一个元素，而 += 会将另一个列表中的所有元素都加入到原列表中（即别名为 extend 方法）。但从提问者的提问方式来看，他/她已经了解了这一点。我是否遗漏了其他区别呢？ - DNS

有所不同，因为增强赋值引入了重新绑定（在我的答案中解释）。 - bobince

Answer 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() 方法。

- bobince

Answer 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]) 是相同的。

- vartec

---

s.append接受任意类型并将其添加到列表中；这是真正的追加。s.extend接受可迭代对象（通常是列表）并将可迭代对象合并到s中，修改s的内存地址。它们不是相同的。 - W4t3randWind

Answer 6

不同之处在于 concatenate 会展平结果列表，而 append 则会保持层次结构：

因此，例如使用：

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

使用append，你最终将得到一个列表的列表：

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

使用concatenate代替，你最终得到一个平坦的列表：

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

- SRC2

Answer 7

这里的性能测试结果不正确：

1. 你不应该只运行一次剖面。
2. 如果多次比较 append 与 +=[]，应该将 append 声明为本地函数。
3. 在不同的Python版本（64位和32位）上，时间结果是不同的。

例如：

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

这里有一些很好的测试：Python列表append与+=[]

- Michael

---

尽管如此，该页面中的 += 测试使用 += [one_var]。 如果我们省略创建列表，则 += 成为最快的选项。 - Joe

Answer 8

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

>>> 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] = *修改后的列表*，而这对于元组来说是不起作用的。

- Reinstate Monica

Answer 9

除了其他答案中描述的方面，当您试图构建列表时，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中。

- Chris Upchurch

Answer 10

"+"

不会改变列表

.append() 会改变原有的列表

- Andres