Python中append和extend列表方法的区别

列表方法append()extend()之间有什么区别?

append :在最后追加对象。

 x = [1, 2, 3] x.append([4, 5]) print (x) 

给你: [1, 2, 3, [4, 5]]


extend :通过从迭代中附加元素来扩展列表。

 x = [1, 2, 3] x.extend([4, 5]) print (x) 

给你: [1, 2, 3, 4, 5]

append将一个元素添加到列表中, extend第一个列表与另一个列表(或另一个迭代,不一定是列表)连接起来。

 >>> li = ['a', 'b', 'mpilgrim', 'z', 'example'] >>> li ['a', 'b', 'mpilgrim', 'z', 'example'] >>> li.append("new") >>> li ['a', 'b', 'mpilgrim', 'z', 'example', 'new'] >>> li.insert(2, "new") >>> li ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new'] >>> li.extend(["two", "elements"]) >>> li ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements'] 

从潜入Python 。

在这种情况下,还可以记住string也是可迭代的。

 >>> a = [1, 2] >>> a [1, 2] >>> a.extend('hey') >>> a [1, 2, 'h', 'e', 'y'] 

列表方法追加和扩展有什么区别?

  • append将其参数作为单个元素添加到列表的末尾。 列表本身的长度将增加一个。
  • extend遍历其参数将每个元素添加到列表,扩展列表。 然而,这个列表的长度会随着迭代参数中的许多元素的增加而增加。

append

list.append方法将一个对象附加到列表的末尾。

 my_list.append(object) 

无论对象是数字,string还是其他列表,它都会作为列表中的单个条目添加到my_list的末尾。

 >>> my_list ['foo', 'bar'] >>> my_list.append('baz') >>> my_list ['foo', 'bar', 'baz'] 

所以请记住,列表是一个对象。 如果将另一个列表添加到列表中,则第一个列表将是列表末尾的单个对象(可能不是您想要的):

 >>> another_list = [1, 2, 3] >>> my_list.append(another_list) >>> my_list ['foo', 'bar', 'baz', [1, 2, 3]] #^^^^^^^^^--- single item on end of list. 

extend

list.extend方法通过附加来自迭代器的元素来扩展列表:

 my_list.extend(iterable) 

所以随着扩展,迭代器的每个元素都被附加到列表中。 例如:

 >>> my_list ['foo', 'bar'] >>> another_list = [1, 2, 3] >>> my_list.extend(another_list) >>> my_list ['foo', 'bar', 1, 2, 3] 

请记住,一个string是一个可迭代的,所以如果你用一个string扩展一个列表,你会在迭代string的时候追加每个字符(这可能不是你想要的):

 >>> my_list.extend('baz') >>> my_list ['foo', 'bar', 1, 2, 3, 'b', 'a', 'z'] 

运算符重载, __and__ ,( + )和__iand__+=

list中定义了++=操作符。 它们在语义上类似于扩展。

my_list + another_list在内存中创build第三个列表,所以你可以返回它的结果,但是它要求第二个迭代是一个列表。

my_list += another_list就地修改列表(这就地操作符,列表是可变对象,正如我们所见),所以它不会创build一个新列表。 它也可以像扩展一样工作,因为第二个迭代器可以是任何types的迭代器。

不要混淆 – my_list = my_list + another_list不等于+= – 它给你一个全新的列表分配给my_list。

时间复杂性

追加具有恒定的时间复杂度 ,O(1)。

扩展具有时间复杂度O(k)。

迭代通过多次调用来append增加了复杂性,使其与扩展相当,并且由于在C中实现了extend迭代,所以如果打算将迭代中的连续项追加到列表上,它总是会更快。

性能

你可能想知道什么是更高性能的,因为append可以用来实现和extend一样的结果。 以下function做同样的事情:

 def append(alist, iterable): for item in iterable: alist.append(item) def extend(alist, iterable): alist.extend(iterable) 

那么让我们来计算一下:

 import timeit >>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz"))) 2.867846965789795 >>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz"))) 0.8060121536254883 

结论

我们看到extend运行速度比append速度快得多,并且在语义上更清晰,因此当您打算将迭代中的每个元素附加到列表时 ,它是首选

如果只有一个元素添加到列表中,请使用append

append追加单个元素。 extend附加元素列表。

请注意,如果您传递一个列表来追加,它仍然会添加一个元素:

 >>> a = [1, 2, 3] >>> a.append([4, 5, 6]) >>> a [1, 2, 3, [4, 5, 6]] 

以下两个片段在语义上是等效的:

 for item in iterator: a_list.append(item) 

 a_list.extend(iterator) 

后者可能会更快,因为循环在C中实现

您可以使用“+”来返回扩展,而不是扩展。

 l1=range(10) l1+[11] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11] l2=range(10,1,-1) l1+l2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2] 

类似地+=就地行为,但与appendextend略有不同。 += from appendextend的最大区别之一是在函数作用域中使用时,请参阅这篇博文 。

append()方法将单个项目添加到列表的末尾。

 x = [1, 2, 3] x.append([4, 5]) x.append('abc') print x # gives you [1, 2, 3, [4, 5], 'abc'] 

extend()方法接受一个参数,一个列表,并将参数的每个项目追加到原始列表中。 (列表是作为类来实现的,“创build”列表实际上就是实例化一个类,因此列表中包含了对其进行操作的方法。

 x = [1, 2, 3] x.extend([4, 5]) x.extend('abc') print x # gives you [1, 2, 3, 4, 5, 'a', 'b', 'c'] 

从潜入Python

附加(对象) – 通过将对象添加到列表来更新列表。

 x = [20] # list passed to the append(object) method is treated as a single object. x.append([21,22,23]) #hence the resultant list length will be 2 print x --> [20, [21,22,23]] 

扩展(列表) – 基本上连接2个列表。

 x = [20] #the parameter passed to extend(list) method is treated as a list. #eventually it is 2 list's being concatenated. x.extend([21,22,23]) #here the resultant list's length is 4 print x [20,21,22,23] 

extend()可以和一个迭代器参数一起使用。 这是一个例子。 您希望以这种方式列出清单:

 list2d = [[1,2,3],[4,5,6], [7], [8,9]] 

你要

 >>> [1, 2, 3, 4, 5, 6, 7, 8, 9] 

你可以使用itertools.chain.from_iterable()来做到这一点。 这个方法的输出是一个迭代器。 它的实现等同于

 def from_iterable(iterables): # chain.from_iterable(['ABC', 'DEF']) --> ABCDEF for it in iterables: for element in it: yield element 

回到我们的例子,我们可以做到

 import itertools list2d = [[1,2,3],[4,5,6], [7], [8,9]] merged = list(itertools.chain.from_iterable(list2d)) 

并得到通缉名单。

下面是等效的extend()可以和一个迭代器参数一起使用:

 merged = [] merged.extend(itertools.chain.from_iterable(list2d)) print(merged) >>> [1, 2, 3, 4, 5, 6, 7, 8, 9] 

这相当于使用+运算符进行appendextend

 >>> x = [1,2,3] >>> x [1, 2, 3] >>> x = x + [4,5,6] # Extend >>> x [1, 2, 3, 4, 5, 6] >>> x = x + [[7,8]] # Append >>> x [1, 2, 3, 4, 5, 6, [7, 8]] 

append() :它基本上用于Python中添加一个元素。

例1:

 >> a = [1, 2, 3, 4] >> a.append(5) >> print(a) >> a = [1, 2, 3, 4, 5] 

例2:

 >> a = [1, 2, 3, 4] >> a.append([5, 6]) >> print(a) >> a = [1, 2, 3, 4, [5, 6]] 

extend() :其中extend()用于合并两个列表或在一个列表中插入多个元素。

例1:

 >> a = [1, 2, 3, 4] >> b = [5, 6, 7, 8] >> a.extend(b) >> print(a) >> a = [1, 2, 3, 4, 5, 6, 7, 8] 

例2:

 >> a = [1, 2, 3, 4] >> a.extend([5, 6]) >> print(a) >> a = [1, 2, 3, 4, 5, 6] 

有一个有趣的暗示,但没有解释的一点是扩展比追加更快。 对于任何有内部追加的循环,都应该被认为是由list.extend(processed_elements)来replace。

请记住,增加新的元素可能会导致整个列表的实际行为在内存中更好的位置。 如果这样做是因为我们一次追加1个元素,那么整体性能就会受到影响。 在这个意义上,list.extend类似于“”.join(stringlist)。

追加可以一次添加全部数据。 整个数据将被添加到新创build的索引。 另一方面, extend ,如其名称所示,扩展了当前的arrays。

例如

 list1 = [123, 456, 678] list2 = [111, 222] 

随着append我们得到:

 result = [123, 456, 678, [111, 222]] 

extend我们得到:

 result = [123, 456, 678, 111, 222] 
 Append a dictionary to another one: >>>def asd(): dic = {1:'a',2:'b',3:'c',4:'a'} newdic={5:'v',1:'aa'} for i in dic.keys(): if not newdic.has_key(dic[i]): newdic[i] = dic[i] print "appended one:",newdic >>>asd() appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'} 
 list1 = [1,2,3,4,5] list2 = ["a","b","c","d","e"] 

附加:

 print list.append(list2) 

输出:[1,2,3,4,5,[“a”,“b”,“c”,“d”,“e”]]

扩展:

 print list1.extend(list2) 

输出:[1,2,3,4,5,“a”,“b”,“c”,“d”,“e”]

我希望我能对这个问题做一个有益的补充。 如果你的列表存储了一个特定的types对象,例如Info ,那么extend方法不适合:在for循环中,每次生成一个Info对象,并使用extend将它存储到列表中时,它将失败。 例外如下所示:

TypeError:“Info”对象不可迭代

但是如果你使用append方法,结果是OK的。 因为每次使用extend方法,它总是将它视为一个列表或任何其他集合types,迭代它,并将其放在之前的列表之后。 一个特定的对象显然不能被迭代。

“append”方法将其参数作为单个元素添加到列表中,而“extend”则获取列表并添加其内容。

例如,

延伸

  letters = ['a', 'b'] letters.extend(['c', 'd']) print(letters) # ['a', 'b', 'c', 'd'] 

附加

  letters.append(['e', 'f']) print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']] 

追加与延伸

在这里输入图像描述

通过追加,您可以附加一个将扩展列表的元素:

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

如果你想扩展多个元素,你应该使用extend,因为你只能追加一个元素或一个元素列表:

 >>> a.append([4,5]) >>> a >>> [1,2,3,[4,5]] 

所以你得到一个嵌套列表

相反,扩展可以像这样扩展一个元素

 >>> a.extend([6]) >>> a [1,2,3,[4,5],6] 

或者,与append不同,一次扩展更多的元素,而不会将列表嵌套到原始列表中(这就是扩展名的原因)

 >>> a.extend([7,8,9]) >>> a [1,2,3,[4,5],6,7,8,9] 

重点回顾

在这里输入图像描述

附加

whith追加你在列表中添加一个单一的元素。 如果添加一个附加到另一个列表的列表,这个列表将被视为一个列表,而不仅仅是将单个元素添加到旧列表中:

追加1个元素

 >>> x = [1,2] >>> x.append(3) >>> x [1,2,3] 

追加一个列表

 >>> x = [1,2] >>> x.append([3,4]) >>> x [1,2,[3,4]] 

正如你所看到的,它是在“旧”列表中作为新元素在列表中的列表。

延伸

通过扩展,您可以扩展一个列表,作为parameter passing另一个列表。 您可以传递一个或多个元素的列表(没有嵌套列表)。

 >>> x = [1,2] >>> x.extend([3]) >>> x [1,2,3] >>>> # adding more elements >>> x.extend([4,5,6]) >>> x [1,2,3,4,5,6] 

扩展(L)通过附加给定列表L中的所有项来扩展列表。

 >>> a [1, 2, 3] a.extend([4]) # it is equivalent to a[len(a):] = [4] or a.append(4) >>>a [1, 2, 3, 4] >>> a = [1,2,3] >>> a [1, 2, 3] >>> a[len(a):] = [4] >>> a [1, 2, 3, 4]