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


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

例子:

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

预期结果:

1
2
>>> joinedlist
[1, 2, 3, 4, 5, 6]
相关讨论

您可以使用+操作符来组合它们:

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

mergedlist = listone + listtwo

输出:

1
2
>>> mergedlist
[1,2,3,4,5,6]
相关讨论

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

1
2
3
import itertools
for item in itertools.chain(listone, listtwo):
   # Do something with each list item
相关讨论

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

1
mergedlist = list(set(listone + listtwo))
相关讨论

Python >= 3.5备选方案:[*l1, *l2]

尽管这是一个古老的答案，但是通过接受PEP 448引入了另一种选择，值得一提。

PEP的标题为附加解包一般化，在Python中使用星号*表达式时，通常会减少一些语法限制;有了它，加入两个列表(适用于任何迭代)现在也可以做到:

1
2
3
4
5
6
7
>>> 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所述:

This is also useful as a more readable way of summing iterables into a
list, such as my_list + list(my_tuple) + list(my_range) which is now
equivalent to just [*my_list, *my_tuple, *my_range].

因此，虽然添加+会引起TypeError由于类型不匹配:

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

以下不会:

1
res = [*l, *r]

因为它将首先解压缩迭代器的内容，然后从内容中简单地创建一个list。

你也可以使用extend来添加一个list添加另一个的结尾:

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

这是非常简单的，我认为它甚至在教程中显示:

1
2
3
4
5
>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]
相关讨论

这个问题直接询问关于加入两个列表的问题。然而，即使您正在寻找连接许多列表的方法(包括连接零列表的情况)，它在搜索中也是相当高的。

我认为最好的选择是使用列表理解:

1
2
3
>>> 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]

你也可以创建生成器:

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

旧的答案

考虑这个更通用的方法:

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

将输出:

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

注意，当a是[]或[[1,2,3]]时，这也可以正确工作。

但是，使用itertools可以更有效地做到这一点:

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

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

更新

帕特里克·柯林斯在评论中提出的其他建议也可能对你有用:

1
sum(a, [])
相关讨论

您可以简单地使用+或+=操作符如下:

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

c = a + b

或者:

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

c += (a + b)

此外，如果您希望合并列表中的值是唯一的，您可以这样做:

1
c = list(set(a + b))

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

1
2
3
4
5
>>> 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类方法:

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

你可以选择list.extend函数。

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

输出:

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

相关讨论

在Python 3.3+中，您可以使用以下命令:

1
2
3
4
5
6
7
8
9
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]

或者，如果您想支持任意数量的迭代器:

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]

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

1
2
3
4
5
6
from heapq import merge

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

print list(merge(a, b))
相关讨论

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

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

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

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

或者，如果你不喜欢dunders的使用，你可以使用operator导入:

1
2
3
4
5
6
7
8
9
import operator

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

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

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

有人可能会说这更容易读。

相关讨论

作为一种更通用的方法，对于更多的列表，您可以将它们放在一个列表中，并使用itertools.chain.from_iterable()1函数，基于这个答案，是平铺嵌套列表的最佳方法:

1
2
3
4
>>> 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)。< /订阅>

用Python连接两个列表:

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

如果你不想要任何重复:

1
2
3
4
5
>>> 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]

如果您需要用复杂的排序规则合并两个有序列表，您可能需要像下面的代码那样自己滚动它(使用一个简单的排序规则来提高可读性:-)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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])
1
list(set(listone) | set(listtwo))

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

正如许多人已经指出的，如果一个人需要对两个列表应用完全相同的处理，那么itertools.chain()就是正确的方法。在我的例子中，我有一个标签和一个标志，它们从一个列表到另一个列表是不同的，所以我需要一些稍微复杂一点的东西。事实证明，在幕后itertools.chain()只是做了以下工作:

1
2
3
for it in iterables:
    for element in it:
        yield element

(参见https://docs.python.org/2/library/itertools.html)，所以我从这里得到了灵感，并沿着这条线写了一些东西:

1
2
3
4
5
6
7
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循环可以处理元组变量，因此同时对多个变量进行循环非常简单。

要用另一个列表来扩展列表，有以下几种方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> 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也可用于:

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

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

1
2
3
4
5
mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)
相关讨论

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

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

这给了我们

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

在Python中，可以用这个命令连接两个兼容维度的数组

1
numpy.concatenate([a,b])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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]
相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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))

输出:

1
2
3
4
5
6
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]

使用一个简单的列表理解:

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

它具有使用附加解包一般化的最新方法的所有优点——也就是说，您可以用这种方法连接任意数量的不同迭代器(例如，列表、元组、范围和生成器)——而且它不限于Python 3.5或更高版本。

如果你想要一个新的列表，同时保留两个旧的列表:

1
2
3
4
5
6
7
8
9
10
def concatenate_list(listOne, listTwo):
    joinedList = []
    for i in listOne:
        joinedList.append(i)
    for j in listTwo:
        joinedList.append(j)

    sorted(joinedList)

    return joinedList
相关讨论

您可以使用extends函数

1
listone.extends(listtwo)
相关讨论

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

打印(c)

1
[1,2,3,4,5,6,7,8,9,10]
相关讨论

所以有两种简单的方法。

使用+:它从提供的列表创建一个新列表

例子:

1
2
3
4
5
6
7
8
9
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:它将新列表追加到现有列表。这意味着它不创建单独的列表。

例子:

1
2
3
4
5
6
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是有效的。

相关讨论

你可以使用'+'运算符连接两个列表在Python:

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

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