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

时间：2009-11-12 07:04:09

标签： python list concatenation

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

示例：

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

预期结果：

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

34 个答案:

答案 0 :(得分：3242)

您可以使用+运算符进行组合：

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

mergedlist = listone + listtwo

输出：

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

答案 1 :(得分：255)

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

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

答案 2 :(得分：178)

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

mergedlist = list(set(listone + listtwo))

答案 3 :(得分：154)

Python [*l1, *l2]替代方案：*

尽管这是一个陈旧的答案，但通过接受 PEP 448 引入了另一种替代方案，值得一提。

PEP标题为 其他解压缩一般化 ，在Python中使用带星号的>>> l1 = [1, 2, 3] >>> l2 = [4, 5, 6] #unpack both iterables in a list literal >>> joinedList = [*l1, *l2] >>> print(joinedList) [1, 2, 3, 4, 5, 6] 表达式时，通常会减少一些语法限制;使用它，加入两个列表（适用于任何可迭代的）现在也可以使用：

3.5

此功能是为Python 3.x 定义的，它尚未被移植到SyntaxError系列中的先前版本。在不受支持的版本中，将会引发my_list + list(my_tuple) + list(my_range)。

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

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

  

这也是一种将迭代累加为a的更易读的方法   列表，例如现在的[*my_list, *my_tuple, *my_range]   相当于+。

因为由于类型不匹配而添加TypeError会引发l = [1, 2, 3] r = range(4, 7) res = l + r ：

res = [*l, *r]

以下赢了：

list

因为它首先会解包迭代的内容，然后只是从内容中创建一个break;。

答案 4 :(得分：138)

您还可以使用extend将list添加到另一个的结尾：

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

答案 5 :(得分：68)

这很简单，我认为它甚至出现在the tutorial：

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

答案 6 :(得分：42)

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

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

>>> 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()。

<强>更新

帕特里克柯林斯在评论中提出的备选方案也适用于你：

sum(a, [])

答案 7 :(得分：38)

您只需使用+或+=运算符，如下所示：

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

答案 8 :(得分：24)

值得注意的是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']

答案 9 :(得分：22)

您可以使用list.extend功能。

l1 = [1,2,3]
l2 = [4,5,6]
l1.extend(l2)
print l1

输出：

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

答案 10 :(得分：22)

使用Python 3.3+，您可以使用yield from：

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

def merge(l1, l2):
    yield from l1
    yield from l2

>>> list(merge(listone, listtwo))
[1, 2, 3, 4, 5, 6]

或者，如果要支持任意数量的迭代器：

def merge(*iters):
    for it in iters:
        yield from it

>>> list(merge(listone, listtwo, 'abcd', [20, 21, 22]))
[1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 20, 21, 22]

答案 11 :(得分：16)

如果要以排序形式合并两个列表，可以使用merge库中的heapq函数。

from heapq import merge

a = [1, 2, 4]
b = [2, 4, 6, 7]

print list(merge(a, b))

答案 12 :(得分：13)

如果您无法使用加号运算符（+），则可以使用operator导入：

import operator

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

result = operator.add(listone, listtwo)
print(result)

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

有人可能会说这有点可读性。

答案 13 :(得分：10)

作为更多列表的更通用方法，您可以将它们放在列表中并使用itertools.chain.from_iterable() 1 函数，该函数基于this answer是平展a的最佳方式嵌套列表：

>>> 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.请注意，{2.6}及更高版本中提供了chain.from_iterable()。在其他版本中，请使用chain(*l)。

答案 14 :(得分：9)

如果您需要合并具有复杂排序规则的两个有序列表，您可能必须自己滚动它，就像在下面的代码中一样（使用简单的排序规则以便于阅读:-)）。

list1 = [1,2,5]
list2 = [2,3,4]
newlist = []

while list1 and list2:
    if list1[0] == list2[0]:
        newlist.append(list1.pop(0))
        list2.pop(0)
    elif list1[0] < list2[0]:
        newlist.append(list1.pop(0))
    else:
        newlist.append(list2.pop(0))

if list1:
    newlist.extend(list1)
if list2:
    newlist.extend(list2)

assert(newlist == [1, 2, 3, 4, 5])

答案 15 :(得分：8)

在Python中加入两个列表：

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

如果您不想复制：

>>> a = [1, 2, 3, 4, 5, 6]
>>> b = [5, 6, 7, 8]
>>> c = list(set(a + b))
>>> c
[1, 2, 3, 4, 5, 6, 7, 8]

答案 16 :(得分：7)

list(set(listone) | set(listtwo))

以上代码不保留顺序，从每个列表中删除重复（但不从连接列表中删除）

答案 17 :(得分：7)

您可以使用append()个对象上定义的list方法：

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)

答案 18 :(得分：6)

正如许多人已经指出的那样，itertools.chain()是一种方法，如果需要将完全相同的处理应用于两个列表。在我的情况下，我有一个标签和一个标志，从一个列表到另一个列表不同，所以我需要一些稍微复杂的东西。事实证明，幕后itertools.chain()只需执行以下操作：

for it in iterables:
    for element in it:
        yield element

（见https://docs.python.org/2/library/itertools.html），所以我从这里获取灵感，并写下了这些内容：

for iterable, header, flag in ( (newList, 'New', ''), (modList, 'Modified', '-f')):
    print header + ':'
    for path in iterable:
        [...]
        command = 'cp -r' if os.path.isdir(srcPath) else 'cp'
        print >> SCRIPT , command, flag, srcPath, mergedDirPath
        [...]

这里要理解的要点是列表只是iterable的一个特例，它们就像其他任何对象一样;并且python中的for ... in循环可以使用元组变量，因此同时循环多个变量很简单。

答案 19 :(得分：5)

要用另一个列表扩展列表，可以使用以下几种方法：

>>> listone = [1,2,3]
>>> listome = [4,5,6]
>>>
>>> listone+listome # adding 2 list is actually extending the list
[1, 2, 3, 4, 5, 6]
>>>
>>> listone.extend(listome)
>>> listone
[1, 2, 3, 4, 5, 6]
>>>
>>> listone = [1,2,3]
>>>
>>> listone.__add__(listome)
[1, 2, 3, 4, 5, 6]

还可以使用for loop：

>>> for i in listome:
...     listone.append(i)
...
>>> listone
[1, 2, 3, 4, 5, 6]
>>>

答案 20 :(得分：4)

组合列表列表的一种非常简洁的方法是

list_of_lists = [[1,2,3], [4,5,6], [7,8,9]]
reduce(list.__add__, list_of_lists)

给了我们

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

答案 21 :(得分：4)

使用简单的列表理解：

joined_list = [item for list_ in [list_one, list_two] for item in list_]

它具有使用Additional Unpacking Generalizations的最新方法的所有优点 - 即您可以连接任意数量的不同迭代（例如，列表，元组，范围和生成器） - 并且它＆＃39 ;不限于Python 3.5或更高版本。

答案 22 :(得分：4)

在Python中，您可以使用此命令连接两个尺寸兼容的数组

numpy.concatenate([a,b])

答案 23 :(得分：2)

lst1 = [1,2]

lst2 = [3,4]

def list_combinationer(Bushisms, are_funny):

    for item in lst1:
        lst2.append(item)
        lst1n2 = sorted(lst2)
        print lst1n2

list_combinationer(lst1, lst2)

[1,2,3,4]

答案 24 :(得分：2)

您可以使用'+'运算符来串联Python中的两个列表：

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listSum = []
>>> listSum = listone + listtwo
>>> print(listSum)

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

答案 25 :(得分：1)

另一种方式：

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

答案 26 :(得分：1)

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

 c=a+b
 print(c)

输出： 

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

在上面的代码中，“ +”运算符用于将2个列表连接为一个列表。

另一个解决方案： 

 a=[1,2,3]
 b=[4,5,6]
 c=[] #Empty list in which we are going to append the values of list (a) and (b)

 for i in a:
     c.append(i)
 for j in b:
     c.append(j)

 print(c)

输出： 

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

答案 27 :(得分：0)

所以有两种简单的方法。

  1. 使用+ ：它从提供的列表中创建一个新列表

示例：

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: a + b
Out[3]: [1, 2, 3, 4, 5, 6]

In [4]: %timeit a + b
10000000 loops, best of 3: 126 ns per loop
  1. 使用扩展：它将新列表追加到现有列表中。这意味着它不会创建单独的列表。

示例：

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: %timeit a.extend(b)
10000000 loops, best of 3: 91.1 ns per loop

因此，我们发现在两种最流行的方法中，extend是有效的。

答案 28 :(得分：0)

res.render('userdetail', {user: user[0]})

<强>输出： 

import itertools

A = list(zip([1,3,5,7,9],[2,4,6,8,10]))
B = [1,3,5,7,9]+[2,4,6,8,10]
C = list(set([1,3,5,7,9] + [2,4,6,8,10]))

D = [1,3,5,7,9]
D.append([2,4,6,8,10])

E = [1,3,5,7,9]
E.extend([2,4,6,8,10])

F = []
for a in itertools.chain([1,3,5,7,9], [2,4,6,8,10]):
    F.append(a)


print ("A: " + str(A))
print ("B: " + str(B))
print ("C: " + str(C))
print ("D: " + str(D))
print ("E: " + str(E))
print ("F: " + str(F))

答案 29 :(得分：0)

如果您想要一个新列表，同时保留两个旧列表：

def concatenate_list(listOne, listTwo):
    joinedList = []
    for i in listOne:
        joinedList.append(i)
    for j in listTwo:
        joinedList.append(j)

    sorted(joinedList)

    return joinedList

答案 30 :(得分：-1)

从3.7开始，这些是在python中串联两个（或更多列表）的最受欢迎的stdlib方法。

enter image description here

  

脚注

     
      

  1. 这是一种精巧的解决方案，因为它具有简洁性。但是sum以成对方式执行串联，这意味着这是一个   二次运算，因为必须为每个步骤分配内存。做   如果您的列表很大，请不要使用。

    2.   

  2. 请参阅chain   和   chain.from_iterable   来自文档。您首先需要import itertools。   串联在内存中是线性的，因此这是最好的   性能和版本兼容性。 chain.from_iterable已在2.6中引入。

    3.   

  3. 此方法使用Additional Unpacking Generalizations (PEP 448)，但不能   归纳为N个列表，除非您自己手动解压缩每个列表。

    4.   

  4. a += b和a.extend(b)出于所有实际目的大致相同。 +=在列表中被调用时将在内部调用   list.__iadd__，将第一个列表扩展到第二个列表。

    5.   

2-列表串联

enter image description here

N-列表串联

enter image description here

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

答案 31 :(得分：-1)

我假设您要使用以下两种方法之一：

保留重复的元素

这很容易，只需像字符串那样串联：

def concat_list(l1,l2):
    l3 = l1+l2
    return l3

下一步，如果要消除重复的元素 

def concat_list(l1,l2):
   l3 = []
   for i in [l1,l2]:
     for j in i:   
       if j not in l3:   
         #Check if element exists in final list, if no then add element to list
         l3.append(j)
   return l3

答案 32 :(得分：-3)

你可以在 python 中使用 union() 函数。

joinedlist = union(listone, listtwo)
print(joinedlist)

本质上这是在删除两个列表中的每个重复项中的一个。由于您的列表没有任何重复项，它只返回两个列表的连接版本。

答案 33 :(得分：-5)

nums1[:] = sorted(nums1[:m] + nums2[:n])
相关问题
最新问题