24 回答

• 0

  您可以使用“”来返回扩展，而不是扩展到位 .

  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 的最大区别之一是它在函数范围中使用时，请参阅this blog post .

  回复于 2024-05-04T07:16:09+08:00
• 549

  append（）方法将单个项添加到列表的末尾 .

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

  extend（）方法接受一个参数，一个列表，并将参数的每个项追加到原始列表中 . （列表实现为类 . “创建”列表实际上是实例化类 . 因此，列表具有对其进行操作的方法 . ）

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

  来自Dive Into Python .

  回复于 2024-05-04T07:16:09+08:00
• 13

  我希望我能对这个问题作出有益的补充 . 如果列表存储了特定的类型对象，例如 Info ，则表示 extend 方法不适合：在 for 循环中并且每次生成 Info 对象并使用 extend 将其存储到列表中时，它将失败 . 例外情况如下：

  TypeError：'Info'对象不可迭代

  但是如果使用 append 方法，结果就可以了 . 因为每次使用 extend 方法时，它总是将其视为列表或任何其他集合类型，迭代它，并将其放在上一个列表之后 . 显然，特定对象无法迭代 .

  回复于 2024-05-04T07:16:09+08:00
• -1

  extend（L）通过附加给定列表L中的所有项来扩展列表 .

  >>> a
  [1, 2, 3]
  a.extend([4)  #is eqivalent of a[len(a):] = [4]
  >>>a
  [1, 2, 3, 4]
  a =[1,2,3]
  >>> a
  [1, 2, 3]
  >>> a[len(a):] = [4]
  >>> a
  [1, 2, 3, 4]
  

  回复于 2024-05-04T07:16:09+08:00
• -1

  方法"append"将其参数作为 single element 添加到列表中，而"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']]
  

  回复于 2024-05-04T07:16:09+08:00
• 11

  append() 方法将添加作为单个元素传递给它的参数 .

  extend () 将迭代传递的参数并通过传递迭代的每个元素来扩展列表，基本上它将添加多个元素而不是将整体添加为一个 .

  list1 = [1,2,3,4,5]
  list2 = [6,7,8]
  
  list1.append(list2)
  print(list1)
  #[1,2,3,4,5,[6,7,8]]
  
  list1.extend(list2)
  print(list1)
  #[1,2,3,4,5,6,7,8]
  

  回复于 2024-05-04T07:16:09+08:00
• 5

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

  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]
  

  回复于 2024-05-04T07:16:09+08:00
• 314

  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]
  

  回复于 2024-05-04T07:16:09+08:00
• 50

  append 附加单个元素 . extend 附加元素列表 .

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

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

  回复于 2024-05-04T07:16:09+08:00
• 0

  Append和extend是python中的可扩展性机制之一 .

  附加：将元素添加到列表的末尾 .

  my_list = [1,2,3,4]
  

  要向列表中添加新元素，我们可以按以下方式使用append方法 .

  my_list.append(5)
  

  添加新元素的默认位置始终位于（长度1）位置 .

  插入：插入方法用于克服追加的限制 . 使用insert，我们可以明确定义我们希望插入新元素的确切位置 .

  insert（index，object）的方法描述符 . 它需要两个参数，第一个是我们想要插入元素的索引，第二个是元素本身 .

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

  扩展：当我们想要将两个或多个列表连接到一个列表中时，这非常有用 . 如果我们想要连接两个列表，则不使用extend，结果对象将包含列表列表 .

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

  如果我们尝试访问pos 2中的元素，我们得到一个列表（[3]），而不是元素 . 要加入两个列表，我们必须使用append .

  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]
  

  回复于 2024-05-04T07:16:09+08:00
• 4333

  append：在末尾追加对象 .

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

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

  ---

  extend：通过附加iterable中的元素来扩展列表 .

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

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

  回复于 2024-05-04T07:16:09+08:00
• 35

  将字典附加到另一个字典：

  >>>def foo():
      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
  
  >>>foo()
  Appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'}
  

  回复于 2024-05-04T07:16:09+08:00
• 19

  这有助于我理解当你使用 append 和 extend 时真正发生的事情：

  a = [[1,2,3],[4,5,6]]
  print(a)
  >>> [[1, 2, 3], [4, 5, 6]]
  a.append([6,7,8])
  print(a)
  >>> [[1, 2, 3], [4, 5, 6], [6, 7, 8]]
  a.extend([0,1,2])
  print(a)
  >>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2]
  a=a+[8,9,10]
  print(a)
  >>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2, 8, 9, 10]
  

  回复于 2024-05-04T07:16:09+08:00
• 18

  append "extends"列表（就地） only one item ，传递的单个对象（作为参数） .

  extend "extends"列表（就地）由 as many items as 传递的对象（作为参数）包含 .

  对于 str 对象，这可能会有些混乱 .

  • 如果传递一个字符串作为参数： append 将在结尾添加一个字符串项，但 extend 将添加与该字符串长度一样多的"single" 'str'项 .

  • 如果您传递一个字符串列表作为参数： append 仍然会在末尾添加一个'list'项目， extend 将添加与传递列表的长度一样多的'list'项目 .

  def append_o（a_list，element）：
  a_list.append（元件）
  print（'append：'，end =''）
  对于a_list中的项目：
  print（item，end ='，'）
  打印（）

  def extend_o（a_list，element）：
  a_list.extend（元件）
  print（'extend：'，end =''）
  对于a_list中的项目：
  print（item，end ='，'）
  打印（）
  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,
  

  回复于 2024-05-04T07:16:09+08:00
• 16

  list append和extend之间有什么区别？

  • append 补充道它的参数作为列表末尾的单个元素 . 列表本身的长度将增加一个 .

  • extend 遍历其参数，将每个元素添加到列表中，扩展列表 . 但是，可迭代参数中的许多元素会增加列表的长度 .

  追加

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

  my_list.append(object)
  

  无论对象是什么，无论是数字，字符串，其他列表还是其他内容，它都会作为列表中的单个条目添加到 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 at the end of the list.
  

  延伸

  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]
  

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

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

  运算符重载，__ add __（）和__iadd __（=）

  + 和 += 运算符都是为 list 定义的 . 它们在语义上类似于extend .

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

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

  不要混淆 - my_list = my_list + another_list 不等于 += - 它为您提供了一个分配给my_list的全新列表 .

  时间复杂性

  追加有constant time complexity，O（1） .

  扩展具有时间复杂度O（k） .

  迭代多次调用 append 会增加复杂性，使其等同于extend，并且由于extend的迭代是在C中实现的，如果您打算将迭代中的连续项追加到列表中，它总是会更快 .

  表现

  你可能想知道什么是更高效的，因为append可以用来实现与extend相同的结果 . 以下函数执行相同的操作：

  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
  

  解决时间问题

  评论者说：

  完美的答案，我只是错过了比较只添加一个元素的时机

  做语义正确的事情 . 如果要将所有元素追加到iterable中，请使用 extend . 如果您只是添加一个元素，请使用 append .

  好的，让我们创建一个实验，看看它是如何及时解决的：

  def append_one(a_list, element):
      a_list.append(element)
  
  def extend_one(a_list, element):
      """creating a new list is semantically the most direct
      way to create an iterable to give to extend"""
      a_list.extend([element])
  
  import timeit
  

  而且我们看到，为了使用扩展而创建一个可迭代的方法是一种（轻微的）浪费时间：

  >>> min(timeit.repeat(lambda: append_one([], 0)))
  0.2082819009956438
  >>> min(timeit.repeat(lambda: extend_one([], 0)))
  0.2397019260097295
  

  我们从中了解到，当我们只有一个要追加的元素时，使用 extend 没有任何好处 .

  而且，这些时间并不重要 . 我只是向他们展示一点，在Python中，做语义正确的事情就是做Right Way™ .

  可以想象，您可以测试两个类似操作的时序并获得模糊或反向结果 . 只关注做语义正确的事情 .

  结论

  我们看到 extend 在语义上更清晰，并且当你打算将迭代中的每个元素追加到列表时，它可以比 append 运行得快得多 .

  如果只有一个元素（不是可迭代的）要添加到列表中，请使用 append .

  回复于 2024-05-04T07:16:09+08:00
• 11

  追加vs扩展

  使用append，您可以附加一个扩展列表的元素：

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

  如果要扩展多个元素，则应使用extend，因为您只能附加一个元素或一个元素列表：

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

  这样你就可以得到一个嵌套列表

  相反，使用扩展，您可以像这样扩展单个元素

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

  或者，与append不同，一次扩展更多元素而不将列表嵌套到原始列表中（这就是名称扩展的原因）

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

  用两种方法添加一个元素

  追加1个元素

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

  扩展一个元素

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

  添加更多元素......具有不同的结果

  如果对多个元素使用append，则必须将元素列表作为参数传递，然后您将获得NESTED列表！

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

  使用extend，您可以将列表作为参数传递，但是您将获得一个列表，其中包含未嵌套在旧元素中的新元素 .

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

  因此，使用更多元素，您将使用extend来获取包含更多项的列表 . 您将使用append，将更多元素附加到列表中，但是一个元素是嵌套列表，您可以在代码的输出中清楚地看到 .

  回复于 2024-05-04T07:16:09+08:00
• 4

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

  回复于 2024-05-04T07:16:09+08:00
• 4

  直观地区分它们

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

  这就像 l1 在她的身体内重现一个身体（嵌套） .

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

  这就像两个分离的人结婚并 Build 一个团结的家庭 .

  除此之外，我还制作了所有列表方法的详尽备忘单供您参考 .

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

  回复于 2024-05-04T07:16:09+08:00
• 3

  英语词典将单词 append 和 extend 定义为：

  append ：在书面文件的末尾添加（某物） .
  extend ：做大 . 放大或扩大

  ---

  有了这些知识，现在让我们理解

  1） The difference between append and extend

  append ：

  • 将任何Python对象按原样附加到列表的末尾（即作为列表中的最后一个元素） .

  • 结果列表可以嵌套并包含异构元素（即列表，字符串，元组，字典，集等）

  extend ：

  • 接受任何iterable作为其参数，并使列表更大 .

  • 结果列表总是一维列表（即没有嵌套），并且由于应用了 list(iterable) ，它可能包含异构元素（例如字符，整数，浮点数） .

  2） Similarity between append and extend

  • 两者都只有一个参数 .

  • 两者都就地修改了列表 .

  • 结果，两者都返回 None .

  ---

  Example

  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
  lis.append(object)
  

  回复于 2024-05-04T07:16:09+08:00
• 34

  这相当于使用 + 运算符的 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]]
  

  回复于 2024-05-04T07:16:09+08:00
• 26

  Append一次添加整个数据 . 整个数据将添加到新创建的索引中 . 另一方面， extend ，顾名思义，扩展了当前数组 .

  例如

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

  通过 append ，我们得到：

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

  在 extend 上，我们得到：

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

  回复于 2024-05-04T07:16:09+08:00
• 2

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

  for item in iterator:
      a_list.append(item)
  

  和

  a_list.extend(iterator)
  

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

  回复于 2024-05-04T07:16:09+08:00
• 103

  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.append(["new", 2])
  >>> li
  ['a', 'b', 'mpilgrim', 'z', 'example', ['new', 2]]
  
  >>> 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']
  

  从Dive into Python开始 .

  回复于 2024-05-04T07:16:09+08:00
• -1

  一个有趣的观点，但未被解释，是延伸比追加更快 . 对于任何在其中附加的循环，应该被认为是由list.extend（processed_elements）替换 .

  请记住，推荐新元素可能会导致整个列表在内存中更好地定位 . 如果这样做多次，因为我们一次追加1个元素，整体性能会受到影响 . 从这个意义上说，list.extend类似于“”.join（stringlist） .

  回复于 2024-05-04T07:16:09+08:00