Как объединить два списка в Python?

Question

Как объединить два списка в Python?

Пример:

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

Ожидаемый результат:

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

Answer 1

Вы можете использовать оператор +, чтобы объединить их:

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

joinedlist = listone + listtwo

Выход:

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

Answer 2

Также возможно создать генератор, который просто перебирает элементы в обоих списках. Это позволяет объединять списки (или любые итерируемые) для обработки без копирования элементов в новый список:

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

Answer 3

Вы можете использовать наборы для получения объединенного списка уникальных значений

mergedlist = list(set(listone + listtwo))

Answer 4

Python >= 3.5 альтернатива: [*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]

Эта функциональность была определена для 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 из содержимого.

Answer 5

Вы также можете использовать extend, чтобы добавить list в конец другого:

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

Answer 6

Это довольно просто, и я думаю, что это было даже показано в учебнике :

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

Answer 7

Этот вопрос напрямую задает вопрос о соединении двух списков. Однако поиск довольно высок, даже если вы ищете способ объединения многих списков (включая случай, когда вы присоединяетесь к нулевым спискам).

Я думаю, что лучше всего использовать списочные выражения:

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

Answer 8

Вы можете просто использовать оператор + или += следующим образом:

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

Answer 9

Стоит отметить, что функция 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']

Answer 10

С Python 3.3+ вы можете использовать доходность от :

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]