如何在Python中串联两个列表？
如何在Python中串联两个列表？
例：
listone = [1, 2, 3]
listtwo = [4, 5, 6]
预期结果：
>>> joinedlist
[1, 2, 3, 4, 5, 6]
#1楼
您还可以使用extend来将list添加到另一个list的末尾：
listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
#2楼
值得注意的是， 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']
#3楼
您可以简单地使用+或+=运算符，如下所示：
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))
#4楼
您可以使用+运算符组合它们：
listone = [1,2,3]
listtwo = [4,5,6]
joinedlist = listone + listtwo
输出：
>>> joinedlist
[1,2,3,4,5,6]
#5楼
这很简单，我认为它甚至在本教程中已显示：
>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]
#6楼
也可以创建一个生成器，使用itertools.chain()简单地遍历两个列表中的项目。 这使您可以将列表（或任何可迭代的）链接在一起进行处理，而无需将项目复制到新列表中：
import itertools
for item in itertools.chain(listone, listtwo):
# Do something with each list item
#7楼
您可以使用在list对象上定义的append()方法：
mergedlist =[]
for elem in listone:
mergedlist.append(elem)
for elem in listtwo:
mergedlist.append(elem)
#8楼
如果您需要使用复杂的排序规则合并两个有序列表，则可能需要像下面的代码一样滚动它（使用简单的排序规则以提高可读性:-)）。
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])
#9楼
使用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]
#10楼
如果您不能使用加号（ + ），则可以使用operator import：
import operator
listone = [1,2,3]
listtwo = [4,5,6]
result = operator.add(listone, listtwo)
print(result)
>>> [1, 2, 3, 4, 5, 6]
另外，您也可以使用__add__ dunder函数：
listone = [1,2,3]
listtwo = [4,5,6]
result = list.__add__(listone, listtwo)
print(result)
>>> [1, 2, 3, 4, 5, 6]
#11楼
作为获取更多列表的更通用方法，您可以将它们放在列表中，并使用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) 。
#12楼
如果要以排序形式合并两个列表，则可以使用heapq库中的merge函数。
from heapq import merge
a = [1, 2, 4]
b = [2, 4, 6, 7]
print list(merge(a, b))
#13楼
这个问题直接询问有关加入两个列表的问题。 但是，即使您正在寻找加入许多列表的方式（包括加入零列表的情况），其搜索量也很高。
我认为最好的选择是使用列表推导：
>>> 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() ，请省略list() 。
更新资料
Patrick Collins在评论中建议的替代方法也可能对您有用：
sum(a, [])
#14楼
正如许多人已经指出的那样，如果需要对两个列表进行完全相同的处理 ，则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
[...]
这里要理解的要点是，列表只是可迭代的特例，它们是与其他对象一样的对象。 并且python中的for ... in循环可以使用元组变量，因此同时循环多个变量很简单。
#15楼
Python >= 3.5替代： [*l1, *l2]
值得一提的是，通过接受PEP 448引入了另一种选择。
当在Python中使用带星号*表达式时，PEP的标题为“ 其他解包概述”通常会减少一些语法上的限制； 有了它，加入两个列表（适用于任何可迭代对象）现在也可以使用：
>>> 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 + 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 。
#16楼
您可以使用集合来获取唯一值的合并列表
mergedlist = list(set(listone + listtwo))
#17楼
list(set(listone) | set(listtwo))
上面的代码不保留顺序，而是从每个列表中删除重复项（但不从串联列表中删除）
#18楼
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]
#19楼
如果您想要一个新列表，同时保留两个旧列表：
def concatenate_list(listOne, listTwo):
joinedList = []
for i in listOne:
joinedList.append(i)
for j in listTwo:
joinedList.append(j)
sorted(joinedList)
return joinedList
#20楼
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]
#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 = [item for list_ in [list_one, list_two] for item in list_]
它具有使用附加解包概括的最新方法的所有优点-即您可以以这种方式连接任意数量的不同可迭代对象（例如，列表，元组，范围和生成器）-而且不限于Python 3.5或更高版本。
#23楼
在Python中，您可以使用此命令连接两个兼容维度的数组
numpy.concatenate([a,b])
#24楼
因此，有两种简单的方法。
- 使用
+：它从提供的列表中创建一个新列表
例：
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
- 使用extend ：将新列表追加到现有列表。 这意味着它不会创建单独的列表。
例：
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是有效的。
#25楼
如何在Python中串联两个列表？
从3.7开始，这些是在python中串联两个（或多个）列表的最受欢迎的stdlib方法。
脚注
由于它的简洁性，这是一个不错的解决方案。 但是
sum以成对方式执行级联，这意味着这是二次运算，因为必须为每个步骤分配内存。 如果您的列表很大，请不要使用。请参阅文档中的
chain和chain.from_iterable。 您将需要首先import itertools。 串联在内存中是线性的，因此这在性能和版本兼容性方面是最佳的。chain.from_iterable已在2.6中引入。此方法使用“ 其他解包概述”（PEP 448） ，但除非您手动手动解压缩每个列表，否则无法将其归纳为N个列表。
对于所有实际目的，
a += b和a.extend(b)相等。+=在列表上调用时会在内部调用list.__iadd__，它将第一个列表扩展到第二个列表。
性能
2列表串联 1
N列表串联
1. iadd （ += ）和extend方法就地操作，因此每次测试之前都必须生成一个副本。为了公平起见，所有方法在左侧列表中都有一个预复制步骤，可以忽略。
对其他解决方案的评论
请勿以任何方式，形状或形式直接使用DUNDER METHOD
list.__add__。 实际上，请避免使用笨拙的方法，并使用设计用于它们的运算符和operator功能。 Python具有仔细的语义，这些语义比直接调用dunder更复杂。 这是一个例子 。 因此，总而言之，a.__add__(b)=>不好；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可以使用，但是它的用例是在线性时间内合并排序后的列表。 在任何其他情况下使用它都是一种反模式。从函数中
yield列表元素是一种可以接受的方法，但是chain可以更快更好地做到这一点（它在C中具有代码路径，因此速度很快）。operator.add(a, b)是等效于a + b。 它的用例主要用于动态方法分派。 否则， 我认为a + b较短且可读性更好。 YMMV。
#26楼
nums1[:] = sorted(nums1[:m] + nums2[:n])
#27楼
用+运算符加入列表
test_list1 = [1, 3, 5, 5, 4]
test_list2 = [4, 6, 2, 8, 10]
test_list3 = [7, 5, 2, 9, 11]
# using + operator
# adding mutiple list at once
test_list1 = test_list1 + test_list2 + test_list3