Python和x27之间的区别是什么；s列表方法追加和扩展？

列表方法

append（）

和

extend（）

之间有什么区别？

append

附加单个元素<代码>扩展附加元素列表

请注意，如果传递要追加的列表，它仍会添加一个元素：

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

---

append

将一个元素添加到列表中，并且

extend

将第一个列表与另一个列表（或另一个iterable，不一定是列表）连接起来

：在末尾追加对象

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

给你：

[1,2,3,4,5]

---

：通过追加iterable中的元素来扩展列表

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

---

给你：

[1,2,3,4,5]

以下两个片段在语义上是等价的：

for item in iterator:
    a_list.append(item)

及

后者可能更快，因为循环是在C中实现的。

extend（）

可以与迭代器参数一起使用。这里有一个例子。您希望通过以下方式从列表列表中创建一个列表：

从

你想要

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

您可以使用

itertools.chain.from\u iterable（）

来执行此操作。此方法的输出是一个迭代器。它的实现相当于

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    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（object）

-通过向列表中添加对象来更新列表

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

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

my_list.append(object) 

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

extend（list）

-基本上连接两个列表

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

您可以使用“+”返回extend，而不是就地扩展

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

略有不同。

+=

与

append

和

extend

的最大区别之一是，当它用于函数范围时，请参见。

使用

append（）

方法将单个项添加到列表的末尾

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

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

my_list.append(object) 

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

extend（）。（列表是作为类实现的。“创建”列表实际上是实例化一个类。因此，列表具有对其进行操作的方法。）

From.
这相当于使用
+
操作符添加
和
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]]

一个有趣的点已经被暗示，但没有解释，那就是extend比append快。对于任何包含append-inside的循环，应将其视为替换为list.extend（processed_元素）

请记住，添加新元素可能会导致整个列表重新定位到内存中更好的位置。如果由于一次添加一个元素而多次执行此操作，则总体性能会受到影响。从这个意义上讲，list.extend类似于“.join（stringlist）。
Append一次添加整个数据。整个数据将添加到新创建的索引中。另一方面，顾名思义，
extend
，扩展了当前数组

比如说

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

通过
append
我们得到：

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

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

在
extend
上，我们得到：

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

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

列表方法append和extend之间有什么区别？

append
将其参数作为单个元素添加到列表末尾。列表本身的长度将增加1
extend
迭代其参数，将每个元素添加到列表中，扩展列表。列表的长度将增加iterable参数中的元素数量

追加
list.append
方法将对象追加到列表的末尾

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

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

my_list.append(object) 

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

无论对象是什么，无论是数字、字符串、另一个列表还是其他对象，它都会作为列表中的单个条目添加到
my_list
的末尾

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

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

my_list.append(object) 

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

所以请记住，列表是一个对象。如果将另一个列表附加到列表中，则第一个列表将是列表末尾的单个对象（可能不是您想要的）：

extend
list.extend
方法通过从iterable中添加元素来扩展列表：

my_list.extend(iterable)

因此，使用extend，iterable的每个元素都会附加到列表中。例如：

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

请记住，字符串是一个iterable，因此，如果使用字符串扩展列表，则在迭代字符串时会追加每个字符（这可能不是您想要的）：

操作员过载，
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
（
+
）和
\uuuuuuuuuuuuu
+
和
+=
运算符都是为
列表定义的。它们在语义上类似于extend

我的列表+另一个列表
在内存中创建第三个列表，因此您可以返回它的结果，但它要求第二个iterable是一个列表

my_list+=另一个_list
就地修改列表（如我们所见，它是就地操作符，列表是可变对象），因此它不会创建新列表。它也像extend一样工作，因为第二个iterable可以是任何类型的iterable

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

不要混淆-
我的列表=我的列表+另一个列表
并不等同于
+=
-它会为我的列表提供一个全新的列表

时间复杂性
Append has（），O（1）

Extend具有时间复杂度O（k）

通过对
append
的多次调用进行迭代增加了复杂性，使其等同于extend，而且由于extend的迭代是用C实现的，因此如果您打算将iterable中的连续项追加到列表中，那么它总是会更快

关于“摊销”-来自：

/*这与列表大小成比例的超额分配，腾出空间
*为了进一步的增长。这种过度分配是温和的，但也很严重
*足以在长期内产生线性时间摊销行为
*存在性能不佳的附件时的附件序列（）
*系统realloc（）。

这意味着我们得到了最好的结果
>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]

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

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

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

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

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

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

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
list.append(object)

def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

my_list = [1,2,3,4]

my_list.append(5)

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

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

a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]