python中的append()有什么功能_关于列表：在Python中，“。append（）”和“+ = []”之间有什么区别？...

有什么区别：

1

2some_list1 = []

some_list1.append("something")

和

1

2some_list2 = []

some_list2 += ["something"]

号

为单个项附加if。也许你是说extend。

关于+=与extend比较有趣的例子：stackoverflow.com/questions/3653298/&hellip；

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15Python 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。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21>>> 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开销来进一步提高性能：

1

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

0.15924410999923566

。

+1：这很有趣。无论如何，我都使用append，因为它会导致代码更加清晰。但我没有意识到性能有差别。如果有什么不同的话，我会期望附加速度变慢，因为它是一个有保证的函数调用，而我假设+=会进一步优化。

是否也存在功能差异？例如，让a=[]，b=[4,5,6]，这里如果你做c=a.append(b)，那么c将是一个列表[[4,5,6]]，而c+=b；将导致一个简单的列表c=[4,5,6]。

只需将事情设置得更直接：+=只要输入格式正确，就比扩展或追加提供更好的性能。在当前示例中需要花费时间的是创建["something"]列表。+=大约快15%

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

@Jamesdlin是的！但如果你不知道的话，很容易弄错。再精确一点也不会伤害任何人，对吧？

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16>>> 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和+=之间存在差异。

事实上，append向列表中添加了一个条目，而+=添加的次数与其他列表中的相同(即extend的别名)。但他/她已经知道了，从问题的写作方式来看。我还缺少其他的区别吗？

有一点不同，因为一个增强的任务引入了重新绑定(在我的答案中有解释)。

这是一个很好的观点。

1

2

3

4

5

6

7

8>>> a=[]

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

>>> a

[[1, 2]]

>>> a=[]

>>> a+=[1,2]

>>> a

[1, 2]

。

请注意，append向列表中添加了一个元素，可以是任何元素。+=[]加入了名单。

投票表决是因为这是两者的一个重要区别。干得好。

+=是赋值。当你使用它的时候，你实际上是在说"一些"列表2=一些"列表2+["某物"]"。作业涉及重新绑定，因此：

1

2

3

4

5

6

7

8

9

10

11l= []

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，通常这样做：

1

2

3

4

5

6

7

8

9

10>>> l1= []

>>> l2= l1

>>> l1.append('x')

>>> l1 is l2

True

>>> l1= l1+['x']

>>> l1 is l2

False

但实际上：

1

2

3

4>>> l2= l1

>>> l1+= ['x']

>>> l1 is l2

True

。

这是因为python列表实现了uiadd_uu()以使一个+=增强的赋值短路，而改为调用list.extend()。(这有点奇怪：它通常是按你的意思做的，但原因不明。)

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

1some_list2 += ["something"]

号

实际上是

1some_list2.extend(["something"])

对于一个值，没有区别。文件规定：

s.append(x) same as s[len(s):len(s)] = [x]

s.extend(x) same as s[len(s):len(s)] = x

号

由此可见，s.append(x)与s.extend([x])相同。

s.append接受一个任意类型并将其添加到列表中；它是一个真正的append。s.extend接受一个iterable(通常是一个列表)，将iterable合并成s，修改s的内存地址。这些不一样。

不同的是，concatenate将使结果列表变平，而append将保持级别不变：

例如：

1

2

3myList = [ ]

listA = [1,2,3]

listB = ["a","b","c"]

号

使用append，您将得到一个列表列表：

1

2

3

4>> myList.append(listA)

>> myList.append(listB)

>> myList

[[1,2,3],['a',b','c']]

号

相反，使用concatenate可以得到一个简单的列表：

1

2

3>> myList += listA + listB

>> myList

[1,2,3,"a","b","c"]

号

此处的性能测试不正确：

你不应该只运行一次配置文件。

如果比较append与+=[]的次数，则应将append声明为本地函数。

不同的python版本的时间结果不同：64位和32位

例如

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

号

好的测试可以在这里找到：http://markandclick.com/1/post/2012/01/python-list-append-vs.html

不过，该页中的+=测试使用+= [one_var]。如果忽略创建列表，+=将成为最快的选项。

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

1

2

3

4

5

6

7

8>>> 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']作为单个元素添加到列表1中。

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

1

2

3

4

5

6

7

8>>> a = ([],[])

>>> a[0].append(1)

>>> a

([1], [])

>>> a[1] += [1]

Traceback (most recent call last):

File"", line 1, in

TypeError: 'tuple' object does not support item assignment

号

这是因为，即使对象在适当的位置发生了变异，增强的赋值也总是会重新绑定。这里的重新绑定碰巧是a[1] = *mutated list*，它不适用于tuples。

append()方法将单个项添加到现有列表中。它不会返回新列表，而是修改原始列表。

1

2some_list1 = []

some_list1.append("something")

号

所以这里有些列表1会被修改。

而使用+组合列表元素将返回一个新列表。

1

2some_list2 = []

some_list2 += ["something"]

号

所以这里的一些列表2和["something"]是两个组合在一起的列表，返回一个新的列表，分配给一些列表2

我们先举个例子

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15list1=[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

号