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

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

Пример:

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

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

>>> joinedlist
[1, 2, 3, 4, 5, 6]
+2047
12 нояб. '09 в 7:04
источник поделиться
34 ответа
  • 1
  • 2

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

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

joinedlist = listone + listtwo

Выход:

>>> joinedlist
[1,2,3,4,5,6]
+3256
12 нояб. '09 в 7:07
источник

Связанные вопросы


Похожие вопросы

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

import itertools
for item in itertools.chain(listone, listtwo):
   # Do something with each list item
+256
12 нояб. '09 в 20:01
источник

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

mergedlist = list(set(listone + listtwo))
+178
20 сент. '10 в 8:43
источник

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

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


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

Это также полезно как более читаемый способ суммирования итераций в список, такой как my_list + list(my_tuple) + list(my_range) который теперь эквивалентен только [*my_list, *my_tuple, *my_range].

Таким образом, в то время как добавление с + TypeError бы TypeError из-за несоответствия типа:

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

Ниже не будет:

res = [*l, *r]

потому что он сначала распакует содержимое итераций, а затем просто создаст list из содержимого.

+157
25 февр. '16 в 15:13
источник

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

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
+139
22 янв. '13 в 7:51
источник

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

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]
+69
12 нояб. '09 в 7:07
источник

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

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

>>> 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, [])
+43
09 окт. '15 в 23:21
источник

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

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))
+38
05 мар. '13 в 9:15
источник

Стоит отметить, что функция 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']
+24
05 февр. '13 в 5:01
источник

С 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]
+22
21 июл. '14 в 0:53
источник

Вы можете перейти к функции list.extend.

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

Вывод:

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

+22
20 февр. '18 в 21:05
источник

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

from heapq import merge

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

print list(merge(a, b))
+16
07 июл. '15 в 13:30
источник

Если вы не можете использовать оператор плюс (+), вы можете использовать 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]
+12
20 окт. '14 в 9:32
источник

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

+10
06 июл. '15 в 20:06
источник

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

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
07 нояб. '13 в 18:04
источник

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

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

Если вы не хотите дублирования:

>>> 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]
+8
29 авг. '15 в 18:03
источник
list(set(listone) | set(listtwo))

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

+6
07 июл. '16 в 7:42
источник

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

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)
+6
16 июл. '13 в 2:02
источник

Как уже отмечалось многими, 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
02 нояб. '15 в 18:59
источник

Чтобы расширить список другим, есть несколько методов, как показано ниже:

>>> 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 также можно использовать:

>>> for i in listome:
...     listone.append(i)
...
>>> listone
[1, 2, 3, 4, 5, 6]
>>>
+5
14 дек. '18 в 21:19
источник

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

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

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

+3
04 июн. '18 в 12:49
источник

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

numpy.concatenate([a,b])
+3
04 авг. '18 в 17:29
источник

Очень сжатый способ комбинировать список списков

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]
+3
26 мар. '18 в 17:48
источник

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

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

enter image description here

Сноски

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

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

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

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


Спектакль

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

enter image description here

Конкатенация N-List

enter image description here

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

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


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

  • НЕ ИСПОЛЬЗУЙТЕ list.__add__ DUNDER METHOD list.__add__ напрямую любым способом, в любой форме. На самом деле, держитесь подальше от более сложных методов и используйте операторы и operator функции, для которых они предназначены. Python имеет тщательно продуманную семантику, которая сложнее, чем просто вызов dunder напрямую. Вот пример. Итак, подведем итоги: a.__add__(b) => BAD; a + b => ХОРОШО.

  • В некоторых ответах здесь предложено reduce(operator.add, [a, b]) для парной конкатенации - это то же самое, что sum([a, b], []) только более многословная.

  • Любой метод, который использует set, удалит дубликаты и потеряет порядок. Используйте с осторожностью.

  • for я in b: a.append(i) является более многословным и более медленным, чем a.extend(b), который является одиночным вызовом функции и более идиоматическим. append медленнее из-за семантики, с которой память выделяется и увеличивается для списков. Смотрите здесь для аналогичного обсуждения.

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

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

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

+3
01 июн. '19 в 15:20
источник
list1 = [1,2,3]
list2 = [4,5,6]

joinedlist = list1 + list2
#Output : [1, 2, 3, 4, 5, 6]

Да, это так просто.

list1 + list2. Это дает новый список, который является конкатенацией list1 и list2.

+3
03 дек. '17 в 1:18

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

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

   [1, 2, 3, 4, 5, 6]
+2
14 дек. '18 в 21:02
источник
a = [1,2,3,4,5,6]
b = [7,8,9,10]
c = a.extend(b)

print (c) дает

[1,2,3,4,5,6,7,8,9,10]
+1
08 авг. '18 в 20:28
источник

Вы можете использовать функцию extends

listone.extends(listtwo)
+1
15 апр. '18 в 1:21
источник
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
06 янв. '17 в 2:54
источник

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

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

    sorted(joinedList)

    return joinedList
0
11 июн. '17 в 17:46
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос