提问



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


例:


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


预期结果:


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

最佳参考


您可以使用+运算符组合它们:


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

mergedlist = listone + listtwo


输出:


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

其它参考1


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


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

其它参考2


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


mergedlist = list(set(listone + listtwo))

其它参考3


您也可以使用extend添加list添加另一个的结尾:[83]


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

其它参考4


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


虽然这是一个陈旧的答案,但是通过接受值得一提的 PEP 448 引入了另一种选择。 [84]


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]


此功能是为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


以下赢了t:


res = [*l, *r]


因为它将首先解包迭代的内容,然后简单地从内容创建list

其它参考5


这很简单,我认为它甚至在教程中显示:[85]


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

其它参考6


您可以简单地使用++=运算符,如下所示:


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

其它参考7


这个问题直接询问加入两个列表。然而,即使您正在寻找加入许多列表的方式(包括加入零列表时的情况),它在搜索中也相当高。考虑这种更通用的方法:


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, [])

其它参考8


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


使用Python 3.3+,您可以使用以下产量:[86]


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]

其它参考10


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


from heapq import merge

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

print list(merge(a,b))

其它参考11


如果你不能使用加号运算符(+),你可以使用__add__函数:


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

result = list.__add__(listone, listtwo)
print(result)

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


或者,如果你不喜欢使用dunders,你可以使用operator导入:[87]


import operator

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

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

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


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

其它参考12


你可以去list.extend函数。[88]


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


输出:


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

其它参考13


作为更多列表的更通用方法,您可以将它们放在列表中并使用itertools.chain.from_iterable() 1 函数,该函数基于此答案是展平嵌套列表的最佳方式:]]


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



其它参考14


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

其它参考15


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


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

其它参考16


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


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


(请参阅https://docs.python.org/2/library/itertools.html),所以我从这里获取灵感并按照这些方式写了一些东西:[90]


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


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

其它参考17


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


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

其它参考18


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


上面的代码,不保留顺序,从每个列表中删除重复(但不从连接列表中删除)

其它参考19


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]

其它参考20


您可以使用extends功能


listone.extends(listtwo)

其它参考21


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


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]

其它参考22


我很惊讶似乎没有人建议使用简单的列表理解:


joined_list = [y for x in [list_one, list_two] for y in x]


它具有使用附加解包概括的最新方法的所有优点 - 即您可以连接任意数量的不同迭代(例如列表,元组,范围,生成器) - 并且它不限于Python >= 3.5 [91]

其它参考23


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


输出:


A: [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
B: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
C: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
D: [1, 3, 5, 7, 9, [2, 4, 6, 8, 10**]
E: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
F: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

其它参考24


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


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

sorted(joinedList)

return joinedList