如何在 Python 中连接两个列表？

太过爱你忘了你带给我的痛 2024-03-30 11:03 76阅读 0赞

## 问： ##

这个问题的答案是社区的努力。编辑现有答案以改进这篇文章。它目前不接受新的答案或交互。

如何在 Python 中连接两个列表？

例子：

listone = [1, 2, 3]
    listtwo = [4, 5, 6]

预期结果：

>>> joinedlist
    [1, 2, 3, 4, 5, 6]

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

## 答1: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

使用 + 运算符组合列表：

listone = [1, 2, 3]
    listtwo = [4, 5, 6]
    
    joinedlist = listone + listtwo

输出：

>>> joinedlist
    [1, 2, 3, 4, 5, 6]

`这会创建listone 的深层副本并附加listtwo 吗？`

`@Daniel 它将创建一个新列表，其中包含第一个列表中项目的浅表副本，然后是第二个列表中项目的浅表副本。使用 copy.deepcopy 获取列表的深层副本。`

`此处还有另一个有用的细节：listone += listtwo 结果为 listone == [1, 2, 3, 4, 5, 6]`

`@br1ckb0t 这会改变listone 指向的内容吗？那么：list3 = listone listone+=listtwo list3 是否也发生了变化？`

`@Pygmalion 这不是 Python3 特定的，而是特定于 NumPy 数组如何处理运算符的。请参阅 Robert Rossney 的答案中 JF Sebastian 的答案，以连接 NumPy 数组。`

## 答2: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

Python >= 3.5 替代方案：\[\*l1, \*l2\]

通过接受 PEP 448 引入了另一种替代方案，值得一提。

PEP 的标题为 Additional Unpacking Generalizations，在 Python 中使用带星号的 \* 表达式时通常会减少一些语法限制；有了它，加入两个列表（适用于任何可迭代）现在也可以通过以下方式完成：

>>> l1 = [1, 2, 3]
    >>> l2 = [4, 5, 6]
    >>> joined_list = [*l1, *l2]  # unpack both iterables in a list literal
    >>> print(joined_list)
    [1, 2, 3, 4, 5, 6]

此功能是为 Python 3.5 定义的，尚未向后移植到 3.x 系列中的先前版本。在不受支持的版本中，将引发 SyntaxError。

与其他方法一样，这也会创建相应列表中元素的浅表副本。

这种方法的好处是你真的不需要列表来执行它，任何可迭代的东西都可以。如 PEP 中所述：

这对于将可迭代对象汇总到列表中也很有用，例如 my\_list + list(my\_tuple) + list(my\_range) 现在相当于 \[\*my\_list, \*my\_tuple, \*my\_range\]。

因此，虽然与 + 相加会由于类型不匹配而引发 TypeError：

l = [1, 2, 3]
    r = range(4, 7)
    res = l + r

以下不会：

res = [*l, *r]

因为它会首先解压可迭代对象的内容，然后简单地从内容中创建一个 list。

`处理可迭代类型的解包方法的一个很好的例子是函数返回一个迭代器，该迭代器覆盖您要连接的列表之一。例如，您可以反转您要连接的列表之一：res = [*l1, *reversed(l2)]。由于 reversed 返回一个迭代器，所以 res = l1 + reversed(l2) 会抛出一个错误。`

`值得注意的是，这类似于在 python 中组合字典。 dict3 = {**dict1, **dict2}。请注意，我们使用 ** 来解包字典，而对于列表，我们使用 * 来解包。`

`我的语法 nazy 必须指出：*dictionaries`

`这是一个很好的解决方案。但是，它不适用于列表理解。`

`@KevinS 这仅适用于字符串键，因为 ** 语法仅支持字符串键。`

## 答3: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

也可以创建一个生成器，使用 itertools.chain() 简单地迭代两个列表中的项目。这允许您将列表（或任何可迭代的）链接在一起进行处理，而无需将项目复制到新列表：

import itertools
    for item in itertools.chain(listone, listtwo):
        # Do something with each list item

`chain 对于两个列表来说速度较慢（但不是很多），但它是链接多个列表的最快解决方案（n > > 2）。`

`@cs95 比什么慢？`

`@Moberg 与连接列表的其他方式相比，请参阅我的基准测试here以供参考。`

`@cs95 您的基准测试使用 chain 对所有元素进行迭代，但会将结果转换为列表。有时这正是您想要的，但如果您只是想遍历所有元素，您可以简单地使用 chain 中的迭代器。这可能要快得多。`

## 答4: ##

> huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。

您还可以使用 list.extend() 方法将 list 添加到另一个末尾：

listone = [1,2,3]
    listtwo = [4,5,6]
    
    listone.extend(listtwo)

如果您想保持原始列表完好无损，您可以创建一个新的 list 对象，并将 extend 两个列表都添加到它：

mergedlist = []
    mergedlist.extend(listone)
    mergedlist.extend(listtwo)

`为什么在我的情况下此方法返回 None？`

`listone = [1,2,3]; listtwo = [4,5,6]; listone.extend(listtwo) 这返回给我None`

`它对 listone 进行就地更新。所以检查它在列表 listone 中`

`实际上，我正在返回一个表达式，我正在使用您提到的方法扩展列表。我没有像 this 帖子中所说的那样重新分配列表。我的表达式类似于 return list1.extend(list2)，这个表达式返回 None 给我。`

`@Ayush 扩展方法使用 listtwo 中的值更新 listone 并返回 None。你想做： listone.extend(listtwo) 后跟 return listone`

## 答5: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

您可以使用集合来获取唯一值的合并列表

mergedlist = list(set(listone + listtwo))

`没错，但是，如果您对此感兴趣，它也会删除重复项。列表添加不会这样做。`

`这样做并保留订购信息的方法是什么？`

`优于listone + [x for x in listtwo if x not in listone]`

`+1 恕我直言，这是“合并”（联合）列表的正确方法，而“已批准”的答案描述了如何组合/添加列表（多集）`

`如果您关心维护输入顺序，那么 import collections; mergedlist = list(collections.OrderedDict.fromkeys(listone + listtwo)) 可以解决问题。`

## 答6: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

如何在 Python 中连接两个列表？

从 3.9 开始，这些是在 python 中连接两个（或更多）列表的最流行的 stdlib 方法。

https://i.stack.imgur.com/cRqfa.png

脚注 这是一个巧妙的解决方案，因为它简洁。但是 sum 以成对的方式执行连接，这意味着这是一个二次运算，因为必须为每个步骤分配内存。如果您的列表很大，请勿使用。请参阅文档中的 chain 和 chain.from\_iterable。您需要先导入 itertools。串联在内存中是线性的，因此在性能和版本兼容性方面这是最好的。 chain.from\_iterable 是在 2.6 中引入的。此方法使用 Additional Unpacking Generalizations (PEP 448)，但不能泛化到 N 个列表，除非您自己手动解包每个列表。 a += b 和 a.extend(b) 或多或少等效于所有实际目的。 += 在列表上调用时将在内部调用 list.**iadd**，它将第一个列表扩展第二个。

表现

2-列表连接1

https://i.stack.imgur.com/mfQTe.png

这些方法之间没有太大区别，但这是有道理的，因为它们都具有相同的复杂度（线性）。除了风格问题外，没有特别的理由偏爱其中一个。

N-List 连接

https://i.stack.imgur.com/XcX7A.png

绘图已使用 perfplot 模块生成。 Code, for your reference.

<子> 1。 iadd (+=) 和 extend 方法就地运行，因此每次测试前都必须生成一个副本。为了公平起见，所有方法都有一个可以忽略左侧列表的预复制步骤。

对其他解决方案的评论

不要以任何方式、形状或形式直接使用 DUNDER METHOD list.**add**。事实上，不要使用 dunder 方法，并按照它们的设计用途使用运算符和运算符函数。 Python 有仔细的语义，这些语义比直接调用 dunder 更复杂。这是一个例子。所以，总而言之，a.**add**(b) => BAD; a + b => 好。

这里的一些答案为成对连接提供了 reduce(operator.add, \[a, b\]) - 这与 sum(\[a, b\], \[\]) 相同，只是更冗长。

任何使用 set 的方法都会删除重复项并失去排序。谨慎使用。

for i in b: a.append(i) 比 a.extend(b) 更冗长，更慢，a.extend(b) 是单个函数调用，更惯用。由于为列表分配和增长内存的语义，append 速度较慢。有关类似讨论，请参见此处。

heapq.merge 可以工作，但它的用例是在线性时间内合并排序列表。在任何其他情况下使用它都是一种反模式。

从函数中产生列表元素是一种可接受的方法，但 chain 做得更快更好（它在 C 中有一个代码路径，所以它很快）。

operator.add(a, b) 是可接受的等效于 a + b 的函数。它的用例主要用于动态方法分派。否则，在我看来，更喜欢更短且更具可读性的 a + b 。 YMMV。

`stackoverflow.com/q/36863404/125507 的答案可以使用 perfplot 图（包括 numba 解决方案）`

`@endolith 有点忙于工作，但我会看看我是否可以加入。Ty。`

`哪种方法最好，然后性能明智，速度更快？请告诉。`

`@ganeshdeshmukh TL;DR 是他们都很好，你选择哪一个主要是风格问题。 "There's not much difference between these methods but that makes sense given they all have the same order of complexity (linear). There's no particular reason to prefer one over the other except as a matter of style.”我的答案中未列出或在“评论”中批评的解决方案，我建议不要使用。`

## 答7: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

这很简单，我认为它甚至显示在 the tutorial 中：

>>> listone = [1,2,3]
    >>> listtwo = [4,5,6]
    >>>
    >>> listone + listtwo
    [1, 2, 3, 4, 5, 6]

## 答8: ##

> huntsbot.com高效搞钱，一站式跟进超10+任务平台外包需求

这个问题直接询问加入两个列表。然而，即使您正在寻找一种加入许多列表的方法（包括加入零列表的情况），它的搜索量也相当高。

我认为最好的选择是使用列表推导：

>>> a = [[1,2,3], [4,5,6], [7,8,9]]
    >>> [x for xs in a for x in xs]
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

您也可以创建生成器：

>>> map(str, (x for xs in a for x in xs))
    ['1', '2', '3', '4', '5', '6', '7', '8', '9']

旧答案

考虑这种更通用的方法：

a = [[1,2,3], [4,5,6], [7,8,9]]
    reduce(lambda c, x: c + x, a, [])

将输出：

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

请注意，当 a 为 \[\] 或 \[\[1,2,3\]\] 时，这也可以正常工作。

但是，使用 itertools 可以更有效地完成此操作：

a = [[1,2,3], [4,5,6], [7,8,9]]
    list(itertools.chain(*a))

如果您不需要 list，而只需要一个可迭代的，则省略 list()。

更新

Patrick Collins 在评论中建议的替代方案也可以为您工作：

sum(a, [])

`Python 3 注意：reduce 现在在 functools 中，因此您需要先导入它。`

## 答9: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

您可以简单地使用 + 或 += 运算符，如下所示：

a = [1, 2, 3]
    b = [4, 5, 6]
    
    c = a + b

或者：

c = []
    a = [1, 2, 3]
    b = [4, 5, 6]
    
    c += (a + b)

此外，如果您希望合并列表中的值是唯一的，您可以执行以下操作：

c = list(set(a + b))

`最后一部分可以任意重新排序物品。如果您想保留顺序，在 CPython 3.6+ 上您可以执行 list(dict.fromkeys(a + b))`

## 答10: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

值得注意的是，itertools.chain 函数接受可变数量的参数：

>>> l1 = ['a']; l2 = ['b', 'c']; l3 = ['d', 'e', 'f']
    >>> [i for i in itertools.chain(l1, l2)]
    ['a', 'b', 'c']
    >>> [i for i in itertools.chain(l1, l2, l3)]
    ['a', 'b', 'c', 'd', 'e', 'f']

如果输入是可迭代的（元组、列表、生成器等），则可以使用 from\_iterable 类方法：

>>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']]
    >>> [i for i in itertools.chain.from_iterable(il)]
    ['a', 'b', 'c', 'd', 'e', 'f']

## 答11: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

对于列表数量较少的情况，您可以简单地将列表添加在一起或使用就地解包（在 Python-3.5+ 中可用）：

In [1]: listone = [1, 2, 3] 
       ...: listtwo = [4, 5, 6]                                                                                                                                                                                 
    
    In [2]: listone + listtwo                                                                                                                                                                                   
    Out[2]: [1, 2, 3, 4, 5, 6]
                                                                                                                                                                                         
    In [3]: [*listone, *listtwo]                                                                                                                                                                                
    Out[3]: [1, 2, 3, 4, 5, 6]

对于具有更多列表的情况，作为更通用的方法，您可以使用 itertools 模块中的 chain.from\_iterable()1 函数。另外，基于this answer，这个函数是最好的；或者至少也是扁平化嵌套列表的一种很好的方法。

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

1.  请注意，`chain.from_iterable()` 在 Python 2.6 及更高版本中可用。在其他版本中，使用 `chain(*l)`。

原文链接：[https://www.huntsbot.com/qa/9rgV/how-do-i-concatenate-two-lists-in-python?lang=zh\_CN&from=csdn][https_www.huntsbot.com_qa_9rgV_how-do-i-concatenate-two-lists-in-python_lang_zh_CN_from_csdn]

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

[https_www.huntsbot.com_qa_9rgV_how-do-i-concatenate-two-lists-in-python_lang_zh_CN_from_csdn]: https://www.huntsbot.com/qa/9rgV/how-do-i-concatenate-two-lists-in-python?lang=zh_CN&from=csdn