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]
类似地+=就地行为，但与append ＆ extend略有不同。 += from append和extend的最大区别之一是在函数作用域中使用时，请参阅这篇博文 。
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]
这相当于使用+运算符进行append和extend ：
>>> 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]
