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

Примере:

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

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

>>> joinedlist
[1, 2, 3, 4, 5, 6]
2793
y2k 12 Ноя 2009 в 10:04

24 ответа

Лучший ответ

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

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

joinedlist = listone + listtwo

Выход:

>>> joinedlist
[1,2,3,4,5,6]
4278
TrebledJ 7 Июн 2019 в 06:45

Стоит отметить, что функция 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']
29
Dariusz Walczak 5 Фев 2013 в 05:01
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]
-2
Dimitris Fasarakis Hilliard 4 Июл 2017 в 12:00

Если вам нужен новый список с сохранением двух старых списков:

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

    sorted(joinedList)

    return joinedList
-1
Ukendar Vadivel 31 Июл 2018 в 09:35
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]
-1
JamesVeug 16 Фев 2018 в 03:46

В Python вы можете объединить два массива совместимых измерений с помощью этой команды

numpy.concatenate([a,b])
4
Cody Gray 26 Июл 2020 в 17:00

Действительно краткий способ объединить список списков

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]
4
Akash Singh 29 Июн 2018 в 12:16

Используйте простой список:

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

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

6
z33k 23 Апр 2019 в 20:39

Как уже указывалось многими, 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
        [...]

Здесь необходимо понять, что списки - это просто частный случай итерации, которые являются объектами, подобными любым другим; и что for ... in циклы в python могут работать с переменными кортежа, поэтому легко зациклить несколько переменных одновременно.

6
Francesco Marchetti-Stasi 2 Ноя 2015 в 18:59
list(set(listone) | set(listtwo))

Приведенный выше код не сохраняет порядок, удаляет дубликаты из каждого списка (но не из объединенного списка)

7
SuperNova 7 Июл 2016 в 07:42

Вы можете использовать метод append(), определенный для объектов list:

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)
7
Dimitris Fasarakis Hilliard 5 Май 2016 в 09:05

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

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])
12
Peter Mortensen 22 Дек 2013 в 09:23

В качестве более общего способа для большего количества списков вы можете поместить их в список и использовать функцию 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).

17
Kasravnd 16 Июл 2020 в 19:46

Если вы не можете использовать оператор плюс (+), вы можете использовать импорт operator:

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]
17
jpihl 4 Июн 2019 в 07:09

Если вы хотите объединить два списка в отсортированном виде, вы можете использовать функцию merge из библиотеки heapq.

from heapq import merge

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

print list(merge(a, b))
22
Peter Mortensen 17 Мар 2019 в 09:19

В 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]
25
user688635user688635 21 Июл 2014 в 00:53

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

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))
43
Peter Mortensen 22 Дек 2013 в 09:21

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

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

>>> 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, [])
55
wonder.mice 4 Сен 2018 в 18:15

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

Начиная с версии 3.7, это наиболее популярные методы stdlib для объединения двух (или более) списков в python.

enter image description here

Сноски

  1. Это изящное решение из-за его краткости. Но sum выполняет конкатенацию попарно, что означает, что это квадратичная операция, поскольку память должна быть выделена для каждого шага. ДЕЛАТЬ НЕ ИСПОЛЬЗОВАТЬ, если ваши списки большие.

  2. См. chain а также chain.from_iterable из документов. Сначала вам нужно import itertools. Конкатенация является линейной в памяти, так что это лучший с точки зрения производительность и совместимость версий. chain.from_iterable был введен в 2.6.

  3. Этот метод использует дополнительные обобщения распаковки (PEP 448), но не может обобщить до N списков, если вы сами не распаковываете вручную.

  4. a += b и a.extend(b) более или менее эквивалентны для всех практических целей. += при вызове в списке вызовет внутренне list.__iadd__, который расширяет первый список на второй.


Производительность

Объединение двух списков 1

enter image description here

Объединение N-списков

enter image description here

Графики были созданы с помощью модуля perfplot. код, для вашей справки.

1. Методы iadd (+=) и extend работают на месте, поэтому копию необходимо создавать каждый раз перед тестированием. Чтобы быть справедливым, все методы имеют шаг предварительного копирования для левого списка, который можно игнорировать.


Комментарии к другим решениям

  • НЕ ИСПОЛЬЗУЙТЕ МЕТОД ДАНДЕРА 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), который является вызовом одной функции и более идиоматичен. append медленнее из-за семантики, с которой память выделяется и увеличивается для списков. Смотрите здесь для аналогичного обсуждения.

  • heapq.merge будет работать, но его вариант использования предназначен для объединения отсортированных списков за линейное время. Использование его в любой другой ситуации - это анти-паттерн.

  • yield получение списка элементов из функции является приемлемым методом, но chain делает это быстрее и лучше (у него есть путь к коду в C, поэтому он быстрый).

  • operator.add(a, b) является приемлемым функциональным эквивалентом a + b. Это варианты использования в основном для динамической отправки метода. В противном случае предпочтите a + b, который короче и более читабелен, , на мой взгляд . YMMV .

138
cs95 25 Июл 2020 в 06:36

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

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]
82
Peter Mortensen 17 Мар 2019 в 09:15

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

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
219
4 revs, 3 users 57% 30 Май 2020 в 18:02

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

mergedlist = list(set(listone + listtwo))
229
thefourtheye 2 Апр 2014 в 07:28

Python >= 3.5 альтернатива: [*l1, *l2]

Еще одна альтернатива была введена посредством принятия PEP 448 , который заслуживает упоминания.

PEP под названием Дополнительные обобщения распаковки обычно уменьшает некоторые синтаксические ограничения при использовании помеченного {Python} выражения {X0}} в Python; с его помощью объединение двух списков (применимо к любому итерируемому) теперь также можно сделать с помощью:

>>> 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 будет поднят.

Как и в случае с другими подходами, этот элемент создает также мелкую копию элементов в соответствующих списках.


Преимущество в этом подходе состоит в том, что для его выполнения вам действительно не нужны списки - все, что можно будет повторить. Как указано в ОПТОСОЗ:

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

341
Boris 22 Ноя 2019 в 12:44

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

import itertools
for item in itertools.chain(listone, listtwo):
    # Do something with each list item
344
Boris 22 Ноя 2019 в 12:53
1720421