在 Python 中，“ . append()”和“ + = []”的区别是什么？

小开

在您给出的示例中，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和 +=具有相同的结果; 它们将项添加到列表中，而不产生新列表。使用 +添加两个列表并生成一个新列表。

小开

 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])是一样的

小开

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

请注意，append 向列表中添加了一个元素，这个元素可以是任何元素。

小开

最佳答案

对于您的情况，唯一的区别是性能: 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中浪费 + = version ——。显然 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

小开

除了在其他答案中描述的方面之外，当您试图构建列表列表时，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。Append ([’5’,’6’])将列表[’5’,’6’]作为单个元素添加到 list1。

小开

+ = 是一个赋值。当你使用它的时候，你实际上是在说‘ 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 通常做的那样创建一个新的 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.tended ()。(这是一个有点奇怪的疣: 它通常做你的意思，但令人困惑的原因。)

一般来说，如果您正在追加/扩展一个现有的列表，并且您想要保持对同一个列表的引用(而不是创建一个新的列表) ，那么最好是显式的，并且坚持使用 append ()/tended ()方法。

小开

这里的性能测试不正确:

你不应该只运行一次侧写。
如果多次比较 append和 +=[]，则应将 append声明为本地函数。
不同的 Python 版本(64位和32位)的时间结果是不同的。

例如:。

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

在这里可以找到好的测试: Python 列表 append vs. + = []

小开

其他答复中提到的重新约束行为在某些情况下确实很重要:

>>> 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*，它不适用于元组。

小开

不同之处在于，连接将使得结果列表变平，而 < b > 附录 将保持水平不变:

例如:

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"]

小开

我们先举个例子

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

小开

Append ()方法将一个项添加到现有列表中

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

因此，这里将修改 some _ list1。

更新:

而使用 + 组合现有列表中的列表元素(不止一个元素)类似于扩展(由变化修正)。

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

因此这里 some _ list2和[“ something”]是两个合并的列表。

小开

“ +”没有使列表发生变异

. append () 变异旧列表

小开

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

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