Как объединить два списка в Python?
Примере:
listone = [1, 2, 3]
listtwo = [4, 5, 6]
Ожидаемый результат:
>>> joinedlist
[1, 2, 3, 4, 5, 6]
24 ответа
Вы можете использовать оператор +
для их объединения:
listone = [1,2,3]
listtwo = [4,5,6]
joinedlist = listone + listtwo
Выход:
>>> joinedlist
[1,2,3,4,5,6]
Стоит отметить, что функция 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']
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]
Если вам нужен новый список с сохранением двух старых списков:
def concatenate_list(listOne, listTwo):
joinedList = []
for i in listOne:
joinedList.append(i)
for j in listTwo:
joinedList.append(j)
sorted(joinedList)
return joinedList
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]
В Python вы можете объединить два массива совместимых измерений с помощью этой команды
numpy.concatenate([a,b])
Действительно краткий способ объединить список списков
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]
Используйте простой список:
joined_list = [item for list_ in [list_one, list_two] for item in list_]
Он обладает всеми преимуществами новейшего подхода использования дополнительных обобщений для распаковки - т. е. таким образом вы можете объединить произвольное количество различных итераций (например, списков, кортежей, диапазонов и генераторов) - и это не ограничивается Python 3.5 или новее.
Как уже указывалось многими, itertools.chain()
- путь, если нужно применить одинаковую обработку к обоим спискам. В моем случае у меня были метка и флаг, которые отличались от одного списка к другому, поэтому мне нужно было что-то немного более сложное. Оказывается, за кадром itertools.chain()
просто делает следующее:
for it in iterables:
for element in it:
yield element
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 могут работать с переменными кортежа, поэтому легко зациклить несколько переменных одновременно.
list(set(listone) | set(listtwo))
Приведенный выше код не сохраняет порядок, удаляет дубликаты из каждого списка (но не из объединенного списка)
Вы можете использовать метод append()
, определенный для объектов list
:
mergedlist =[]
for elem in listone:
mergedlist.append(elem)
for elem in listtwo:
mergedlist.append(elem)
Если вам нужно объединить два упорядоченных списка со сложными правилами сортировки, вам, возможно, придется свернуть его самостоятельно, как показано в следующем коде (используя простое правило сортировки для удобства чтения :-)).
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])
В качестве более общего способа для большего количества списков вы можете поместить их в список и использовать функцию 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)
.
Если вы не можете использовать оператор плюс (+
), вы можете использовать импорт 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]
Если вы хотите объединить два списка в отсортированном виде, вы можете использовать функцию merge
из библиотеки heapq
.
from heapq import merge
a = [1, 2, 4]
b = [2, 4, 6, 7]
print list(merge(a, b))
В 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]
Вы можете просто использовать оператор +
или +=
следующим образом:
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))
Этот вопрос напрямую задает вопрос о соединении двух списков. Тем не менее, поиск довольно высок, даже если вы ищете способ объединения многих списков (включая случай, когда вы присоединяетесь к нулевым спискам).
Я думаю, что лучше всего использовать списочные выражения:
>>> 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, [])
Как объединить два списка в Python?
Начиная с версии 3.7, это наиболее популярные методы stdlib для объединения двух (или более) списков в python.
Сноски
Это изящное решение из-за его краткости. Но
sum
выполняет конкатенацию попарно, что означает, что это квадратичная операция, поскольку память должна быть выделена для каждого шага. ДЕЛАТЬ НЕ ИСПОЛЬЗОВАТЬ, если ваши списки большие.См.
chain
а такжеchain.from_iterable
из документов. Сначала вам нужноimport itertools
. Конкатенация является линейной в памяти, так что это лучший с точки зрения производительность и совместимость версий.chain.from_iterable
был введен в 2.6.Этот метод использует дополнительные обобщения распаковки (PEP 448), но не может обобщить до N списков, если вы сами не распаковываете вручную.
a += b
иa.extend(b)
более или менее эквивалентны для всех практических целей.+=
при вызове в списке вызовет внутреннеlist.__iadd__
, который расширяет первый список на второй.
Производительность
Объединение двух списков 1
Объединение N-списков
Графики были созданы с помощью модуля 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 .
Это довольно просто, и я думаю, что это было даже показано в учебнике:
>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]
Вы также можете использовать extend
по порядку. добавить list
в конец другого:
listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
Вы можете использовать наборы для получения объединенного списка уникальных значений
mergedlist = list(set(listone + listtwo))
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
из содержимого.
Также можно создать генератор, который просто перебирает элементы в обоих списках, используя {{ X0 } }. Это позволяет объединять списки (или любые итерируемые) для обработки без копирования элементов в новый список:
import itertools
for item in itertools.chain(listone, listtwo):
# Do something with each list item
Похожие вопросы
Новые вопросы
python
Python - это многопарадигмальный, динамически типизированный, многоцелевой язык программирования. Он разработан для быстрого изучения, понимания и использования, а также для обеспечения чистого и единообразного синтаксиса. Обратите внимание, что Python 2 официально не поддерживается с 01.01.2020. Тем не менее, для вопросов о Python, связанных с версией, добавьте тег [python-2.7] или [python-3.x]. При использовании варианта Python (например, Jython, PyPy) или библиотеки (например, Pandas и NumPy) включите его в теги.