有什么区别：
some_list1 = []
some_list1.append("something")
和
some_list2 = []
some_list2 += ["something"]
【问题讨论】：
extend。
+= vs extend 更有趣的案例：stackoverflow.com/questions/3653298/…
+= vs append stackoverflow.com/q/252703/6674599
标签： python list concatenation
对于您的情况，唯一的区别是性能：追加速度是原来的两倍。
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
【讨论】：
append 与 +=，那么您必须将列表的创建作为衡量的一部分。否则，这将是一个不同的问题（extend vs +=）。
在您给出的示例中，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 的别名）。但是他/她已经知道了，从问题的写法来看。我还缺少其他一些区别吗？
>>> a=[]
>>> a.append([1,2])
>>> a
[[1, 2]]
>>> a=[]
>>> a+=[1,2]
>>> a
[1, 2]
看到 append 将单个元素添加到列表中，它可以是任何元素。 +=[] 加入列表。
【讨论】：
+= 是一个赋值。当你使用它时，你实际上是在说‘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() 方法。
【讨论】：
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]) 相同
【讨论】：
不同之处在于 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"]
【讨论】：
这里的性能测试不正确：
append 和 +=[]，您应该将 append 声明为本地函数。例如
timeit.Timer('for i in xrange(100): app(i)', 's = [] ; app = s.append').timeit()
可以在这里找到好的测试：Python list append vs. +=[]
【讨论】：
+= [one_var]。如果我们省略创建列表，+= 将成为最快的选项。
除了其他答案中描述的方面之外，当您尝试构建列表时， 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。
【讨论】：
其他答案中提到的重新绑定行为在某些情况下确实很重要：
>>> 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*，这对元组不起作用。
【讨论】：
"+" 不会改变列表
.append() 变异旧列表
【讨论】：
我们先举个例子
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 将被修改。
更新：
而使用 + 来组合现有列表中的列表元素（多个元素）类似于扩展（由 Flux 更正）。
some_list2 = []
some_list2 += ["something"]
所以这里 some_list2 和 ["something"] 是两个组合在一起的列表。
【讨论】：
+= 不返回新列表。 Programming FAQ 说：“...对于列表，__iadd__ 相当于在列表上调用 extend 并返回列表。这就是为什么我们说对于列表，+= 是 @987654330 的“简写” @"。你也可以在 CPython 源代码中看到这一点：github.com/python/cpython/blob/v3.8.2/Objects/…
截至今天和 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
【讨论】：